update
This commit is contained in:
320
test/suite/einvoice_pdf-operations/test.pdf-01.extraction.ts
Normal file
320
test/suite/einvoice_pdf-operations/test.pdf-01.extraction.ts
Normal file
@ -0,0 +1,320 @@
|
||||
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';
|
||||
|
||||
tap.test('PDF-01: XML Extraction from ZUGFeRD PDFs - should extract XML from ZUGFeRD v1 PDFs', async () => {
|
||||
// Get ZUGFeRD v1 PDF files from corpus
|
||||
const zugferdV1Files = await CorpusLoader.getFiles('ZUGFERD_V1_CORRECT');
|
||||
const pdfFiles = zugferdV1Files.filter(f => f.endsWith('.pdf'));
|
||||
|
||||
console.log(`Testing XML extraction from ${pdfFiles.length} ZUGFeRD v1 PDFs`);
|
||||
|
||||
let successCount = 0;
|
||||
let failCount = 0;
|
||||
const results: { file: string; success: boolean; format?: string; size?: number; error?: string }[] = [];
|
||||
|
||||
// Import required classes
|
||||
const { EInvoice } = await import('../../../ts/index.js');
|
||||
|
||||
for (const filePath of pdfFiles.slice(0, 5)) { // Test first 5 for performance
|
||||
const fileName = path.basename(filePath);
|
||||
|
||||
try {
|
||||
// Read PDF file
|
||||
const pdfBuffer = await fs.readFile(filePath);
|
||||
|
||||
// Track performance of PDF extraction
|
||||
const { result: einvoice, metric } = await PerformanceTracker.track(
|
||||
'pdf-extraction-v1',
|
||||
async () => {
|
||||
return await EInvoice.fromPdf(pdfBuffer);
|
||||
},
|
||||
{
|
||||
file: fileName,
|
||||
size: pdfBuffer.length
|
||||
}
|
||||
);
|
||||
|
||||
// Verify extraction succeeded
|
||||
expect(einvoice).toBeTruthy();
|
||||
const xml = einvoice.getXml ? einvoice.getXml() : '';
|
||||
expect(xml).toBeTruthy();
|
||||
expect(xml.length).toBeGreaterThan(100);
|
||||
|
||||
// Check format detection
|
||||
const format = einvoice.getFormat ? einvoice.getFormat() : 'unknown';
|
||||
|
||||
successCount++;
|
||||
results.push({
|
||||
file: fileName,
|
||||
success: true,
|
||||
format: format.toString(),
|
||||
size: xml.length
|
||||
});
|
||||
|
||||
console.log(`✓ ${fileName}: Extracted ${xml.length} bytes, format: ${format} (${metric.duration.toFixed(2)}ms)`);
|
||||
|
||||
// Verify basic invoice data (if available)
|
||||
if (einvoice.id) {
|
||||
expect(einvoice.id).toBeTruthy();
|
||||
}
|
||||
if (einvoice.from && einvoice.from.name) {
|
||||
expect(einvoice.from.name).toBeTruthy();
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
failCount++;
|
||||
results.push({
|
||||
file: fileName,
|
||||
success: false,
|
||||
error: error.message
|
||||
});
|
||||
|
||||
console.log(`✗ ${fileName}: ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
console.log(`\nZUGFeRD v1 Extraction Summary: ${successCount} succeeded, ${failCount} failed`);
|
||||
|
||||
// Show results summary
|
||||
const formatCounts: Record<string, number> = {};
|
||||
results.filter(r => r.success && r.format).forEach(r => {
|
||||
formatCounts[r.format!] = (formatCounts[r.format!] || 0) + 1;
|
||||
});
|
||||
|
||||
if (Object.keys(formatCounts).length > 0) {
|
||||
console.log('Format distribution:', formatCounts);
|
||||
}
|
||||
|
||||
// Performance summary
|
||||
const perfSummary = await PerformanceTracker.getSummary('pdf-extraction-v1');
|
||||
if (perfSummary) {
|
||||
console.log(`\nExtraction Performance:`);
|
||||
console.log(` Average: ${perfSummary.average.toFixed(2)}ms`);
|
||||
console.log(` Min: ${perfSummary.min.toFixed(2)}ms`);
|
||||
console.log(` Max: ${perfSummary.max.toFixed(2)}ms`);
|
||||
console.log(` P95: ${perfSummary.p95.toFixed(2)}ms`);
|
||||
}
|
||||
|
||||
// Expect at least some success (ZUGFeRD PDFs should extract)
|
||||
expect(successCount).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
tap.test('PDF-01: XML Extraction from ZUGFeRD v2/Factur-X PDFs - should extract XML from v2 PDFs', async () => {
|
||||
// Get ZUGFeRD v2 PDF files from corpus
|
||||
const zugferdV2Files = await CorpusLoader.getFiles('ZUGFERD_V2_CORRECT');
|
||||
const pdfFiles = zugferdV2Files.filter(f => f.endsWith('.pdf'));
|
||||
|
||||
console.log(`Testing XML extraction from ${pdfFiles.length} ZUGFeRD v2/Factur-X PDFs`);
|
||||
|
||||
const profileStats: Record<string, number> = {};
|
||||
let successCount = 0;
|
||||
|
||||
const { EInvoice } = await import('../../../ts/index.js');
|
||||
|
||||
for (const filePath of pdfFiles.slice(0, 8)) { // Test first 8
|
||||
const fileName = path.basename(filePath);
|
||||
|
||||
try {
|
||||
// Read PDF file
|
||||
const pdfBuffer = await fs.readFile(filePath);
|
||||
|
||||
const { result: einvoice, metric } = await PerformanceTracker.track(
|
||||
'pdf-extraction-v2',
|
||||
async () => {
|
||||
return await EInvoice.fromPdf(pdfBuffer);
|
||||
},
|
||||
{
|
||||
file: fileName,
|
||||
size: pdfBuffer.length
|
||||
}
|
||||
);
|
||||
|
||||
// Extract profile from filename if present
|
||||
const profileMatch = fileName.match(/(BASIC|COMFORT|EXTENDED|MINIMUM|EN16931)/i);
|
||||
const profile = profileMatch ? profileMatch[1].toUpperCase() : 'UNKNOWN';
|
||||
profileStats[profile] = (profileStats[profile] || 0) + 1;
|
||||
|
||||
const format = einvoice.getFormat ? einvoice.getFormat() : 'unknown';
|
||||
console.log(`✓ ${fileName}: Profile ${profile}, Format ${format} (${metric.duration.toFixed(2)}ms)`);
|
||||
|
||||
// Test that we can access the XML
|
||||
const xml = einvoice.getXml ? einvoice.getXml() : '';
|
||||
expect(xml).toBeTruthy();
|
||||
expect(xml).toContain('CrossIndustryInvoice'); // Should be CII format
|
||||
|
||||
successCount++;
|
||||
|
||||
} catch (error) {
|
||||
console.log(`✗ ${fileName}: ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
console.log(`\nZUGFeRD v2/Factur-X Extraction Summary: ${successCount} succeeded`);
|
||||
console.log('Profile distribution:', profileStats);
|
||||
|
||||
// Performance summary
|
||||
const perfSummary = await PerformanceTracker.getSummary('pdf-extraction-v2');
|
||||
if (perfSummary) {
|
||||
console.log(`\nV2 Extraction Performance:`);
|
||||
console.log(` Average: ${perfSummary.average.toFixed(2)}ms`);
|
||||
console.log(` Min: ${perfSummary.min.toFixed(2)}ms`);
|
||||
console.log(` Max: ${perfSummary.max.toFixed(2)}ms`);
|
||||
console.log(` P95: ${perfSummary.p95.toFixed(2)}ms`);
|
||||
}
|
||||
|
||||
expect(successCount).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
tap.test('PDF-01: PDF Extraction Error Handling - should handle invalid PDFs gracefully', async () => {
|
||||
const { EInvoice } = await import('../../../ts/index.js');
|
||||
|
||||
// Test with empty buffer
|
||||
try {
|
||||
await EInvoice.fromPdf(new Uint8Array(0));
|
||||
expect.fail('Should have thrown an error for empty PDF');
|
||||
} catch (error) {
|
||||
console.log('✓ Empty PDF error handled correctly');
|
||||
expect(error.message).toBeTruthy();
|
||||
}
|
||||
|
||||
// Test with non-PDF data
|
||||
try {
|
||||
const textBuffer = Buffer.from('This is not a PDF file');
|
||||
await EInvoice.fromPdf(textBuffer);
|
||||
expect.fail('Should have thrown an error for non-PDF data');
|
||||
} catch (error) {
|
||||
console.log('✓ Non-PDF data error handled correctly');
|
||||
expect(error.message).toBeTruthy();
|
||||
}
|
||||
|
||||
// Test with corrupted PDF header
|
||||
try {
|
||||
const corruptPdf = Buffer.from('%PDF-1.4\nCorrupted content');
|
||||
await EInvoice.fromPdf(corruptPdf);
|
||||
expect.fail('Should have thrown an error for corrupted PDF');
|
||||
} catch (error) {
|
||||
console.log('✓ Corrupted PDF error handled correctly');
|
||||
expect(error.message).toBeTruthy();
|
||||
}
|
||||
|
||||
// Test with valid PDF but no embedded XML
|
||||
const minimalPdf = createMinimalTestPDF();
|
||||
try {
|
||||
await EInvoice.fromPdf(minimalPdf);
|
||||
console.log('○ Minimal PDF processed (may or may not have XML)');
|
||||
} catch (error) {
|
||||
console.log('✓ PDF without XML handled correctly');
|
||||
expect(error.message).toBeTruthy();
|
||||
}
|
||||
});
|
||||
|
||||
tap.test('PDF-01: Failed PDF Extraction - should handle PDFs without XML gracefully', async () => {
|
||||
// Get files expected to fail
|
||||
const failPdfs = await CorpusLoader.getFiles('ZUGFERD_V1_FAIL');
|
||||
const pdfFailFiles = failPdfs.filter(f => f.endsWith('.pdf'));
|
||||
|
||||
console.log(`Testing ${pdfFailFiles.length} PDFs expected to fail`);
|
||||
|
||||
const { EInvoice } = await import('../../../ts/index.js');
|
||||
let expectedFailures = 0;
|
||||
let unexpectedSuccesses = 0;
|
||||
|
||||
for (const filePath of pdfFailFiles) {
|
||||
const fileName = path.basename(filePath);
|
||||
|
||||
try {
|
||||
const pdfBuffer = await fs.readFile(filePath);
|
||||
|
||||
const { result: einvoice } = await PerformanceTracker.track(
|
||||
'pdf-extraction-fail',
|
||||
async () => {
|
||||
return await EInvoice.fromPdf(pdfBuffer);
|
||||
}
|
||||
);
|
||||
|
||||
unexpectedSuccesses++;
|
||||
console.log(`○ ${fileName}: Unexpectedly succeeded (might have XML)`);
|
||||
|
||||
} catch (error) {
|
||||
expectedFailures++;
|
||||
console.log(`✓ ${fileName}: Correctly failed - ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
console.log(`\nFail Test Summary: ${expectedFailures} expected failures, ${unexpectedSuccesses} unexpected successes`);
|
||||
|
||||
// Most files in fail directory should fail
|
||||
if (pdfFailFiles.length > 0) {
|
||||
expect(expectedFailures).toBeGreaterThan(0);
|
||||
}
|
||||
});
|
||||
|
||||
tap.test('PDF-01: Large PDF Performance - should handle large PDFs efficiently', async () => {
|
||||
const { EInvoice } = await import('../../../ts/index.js');
|
||||
|
||||
// Create a larger test PDF (1MB)
|
||||
const largePdfSize = 1024 * 1024; // 1MB
|
||||
const largePdfBuffer = Buffer.alloc(largePdfSize);
|
||||
|
||||
// Create a simple PDF header
|
||||
const pdfHeader = Buffer.from('%PDF-1.4\n');
|
||||
pdfHeader.copy(largePdfBuffer);
|
||||
|
||||
console.log(`Testing with ${(largePdfSize / 1024 / 1024).toFixed(1)}MB PDF`);
|
||||
|
||||
const { metric } = await PerformanceTracker.track(
|
||||
'large-pdf-processing',
|
||||
async () => {
|
||||
try {
|
||||
await EInvoice.fromPdf(largePdfBuffer);
|
||||
return 'success';
|
||||
} catch (error) {
|
||||
// Expected to fail since it's not a real PDF with XML
|
||||
return 'failed';
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
console.log(`✓ Large PDF processed in ${metric.duration.toFixed(2)}ms`);
|
||||
expect(metric.duration).toBeLessThan(5000); // Should fail fast, not hang
|
||||
|
||||
// Test memory usage
|
||||
const memoryUsed = metric.memory ? metric.memory.used / 1024 / 1024 : 0; // MB
|
||||
console.log(`Memory usage: ${memoryUsed.toFixed(2)}MB`);
|
||||
|
||||
if (memoryUsed > 0) {
|
||||
expect(memoryUsed).toBeLessThan(largePdfSize / 1024 / 1024 * 2); // Should not use more than 2x file size
|
||||
}
|
||||
});
|
||||
|
||||
// Helper function to create a minimal test PDF
|
||||
function createMinimalTestPDF(): Uint8Array {
|
||||
const pdfContent = `%PDF-1.4
|
||||
1 0 obj
|
||||
<< /Type /Catalog /Pages 2 0 R >>
|
||||
endobj
|
||||
2 0 obj
|
||||
<< /Type /Pages /Kids [3 0 R] /Count 1 >>
|
||||
endobj
|
||||
3 0 obj
|
||||
<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << >> >>
|
||||
endobj
|
||||
xref
|
||||
0 4
|
||||
0000000000 65535 f
|
||||
0000000009 00000 n
|
||||
0000000058 00000 n
|
||||
0000000115 00000 n
|
||||
trailer
|
||||
<< /Size 4 /Root 1 0 R >>
|
||||
startxref
|
||||
217
|
||||
%%EOF`;
|
||||
|
||||
return new Uint8Array(Buffer.from(pdfContent));
|
||||
}
|
||||
|
||||
tap.start();
|
||||
@ -0,0 +1,357 @@
|
||||
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';
|
||||
|
||||
const testTimeout = 300000; // 5 minutes timeout for PDF processing
|
||||
|
||||
// PDF-02: ZUGFeRD v1 Extraction
|
||||
// Tests XML extraction from ZUGFeRD v1 PDFs with specific format validation
|
||||
// and compatibility checks for legacy ZUGFeRD implementations
|
||||
|
||||
tap.test('PDF-02: ZUGFeRD v1 Extraction - Basic Extraction', async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
// Test basic ZUGFeRD v1 extraction functionality
|
||||
try {
|
||||
const zugferdV1Files = await CorpusLoader.getFiles('ZUGFERD_V1');
|
||||
|
||||
if (zugferdV1Files.length === 0) {
|
||||
tools.log('⚠ No ZUGFeRD v1 files found in corpus, skipping basic extraction test');
|
||||
return;
|
||||
}
|
||||
|
||||
const testFile = zugferdV1Files[0];
|
||||
tools.log(`Testing ZUGFeRD v1 extraction with: ${plugins.path.basename(testFile)}`);
|
||||
|
||||
const invoice = new EInvoice();
|
||||
|
||||
// Check if file exists and is readable
|
||||
const fileExists = await plugins.fs.pathExists(testFile);
|
||||
expect(fileExists).toBe(true);
|
||||
|
||||
const fileStats = await plugins.fs.stat(testFile);
|
||||
tools.log(`File size: ${(fileStats.size / 1024).toFixed(1)}KB`);
|
||||
|
||||
// Attempt PDF extraction
|
||||
let extractionResult;
|
||||
try {
|
||||
extractionResult = await invoice.fromFile(testFile);
|
||||
|
||||
if (extractionResult) {
|
||||
tools.log('✓ ZUGFeRD v1 XML extraction successful');
|
||||
|
||||
// Verify extracted content contains ZUGFeRD v1 characteristics
|
||||
const extractedXml = await invoice.toXmlString();
|
||||
expect(extractedXml).toBeTruthy();
|
||||
expect(extractedXml.length).toBeGreaterThan(100);
|
||||
|
||||
// Check for ZUGFeRD v1 namespace or characteristics
|
||||
const hasZugferdV1Markers = extractedXml.includes('urn:ferd:CrossIndustryDocument:invoice:1p0') ||
|
||||
extractedXml.includes('ZUGFeRD') ||
|
||||
extractedXml.includes('FERD');
|
||||
|
||||
if (hasZugferdV1Markers) {
|
||||
tools.log('✓ ZUGFeRD v1 format markers detected in extracted XML');
|
||||
} else {
|
||||
tools.log('⚠ ZUGFeRD v1 format markers not clearly detected');
|
||||
}
|
||||
|
||||
// Test basic validation of extracted content
|
||||
try {
|
||||
const validationResult = await invoice.validate();
|
||||
if (validationResult.valid) {
|
||||
tools.log('✓ Extracted ZUGFeRD v1 content passes validation');
|
||||
} else {
|
||||
tools.log(`⚠ Validation issues found: ${validationResult.errors?.length || 0} errors`);
|
||||
}
|
||||
} catch (validationError) {
|
||||
tools.log(`⚠ Validation failed: ${validationError.message}`);
|
||||
}
|
||||
|
||||
} else {
|
||||
tools.log('⚠ ZUGFeRD v1 extraction returned no result');
|
||||
}
|
||||
|
||||
} catch (extractionError) {
|
||||
tools.log(`⚠ ZUGFeRD v1 extraction failed: ${extractionError.message}`);
|
||||
// This might be expected if PDF extraction is not fully implemented
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
tools.log(`ZUGFeRD v1 basic extraction test failed: ${error.message}`);
|
||||
}
|
||||
|
||||
const duration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdf-zugferd-v1-basic-extraction', duration);
|
||||
});
|
||||
|
||||
tap.test('PDF-02: ZUGFeRD v1 Extraction - Corpus Processing', { timeout: testTimeout }, async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
let processedFiles = 0;
|
||||
let successfulExtractions = 0;
|
||||
let extractionErrors = 0;
|
||||
let totalExtractionTime = 0;
|
||||
|
||||
try {
|
||||
const zugferdV1Files = await CorpusLoader.getFiles('ZUGFERD_V1');
|
||||
tools.log(`Processing ${zugferdV1Files.length} ZUGFeRD v1 files`);
|
||||
|
||||
if (zugferdV1Files.length === 0) {
|
||||
tools.log('⚠ No ZUGFeRD v1 files found in corpus');
|
||||
return;
|
||||
}
|
||||
|
||||
for (const filePath of zugferdV1Files) {
|
||||
const fileName = plugins.path.basename(filePath);
|
||||
const fileExtractionStart = Date.now();
|
||||
|
||||
try {
|
||||
processedFiles++;
|
||||
|
||||
// Check file accessibility
|
||||
const fileExists = await plugins.fs.pathExists(filePath);
|
||||
if (!fileExists) {
|
||||
tools.log(`⚠ File not found: ${fileName}`);
|
||||
continue;
|
||||
}
|
||||
|
||||
const fileStats = await plugins.fs.stat(filePath);
|
||||
const fileSizeKB = fileStats.size / 1024;
|
||||
|
||||
// Attempt extraction
|
||||
const invoice = new EInvoice();
|
||||
const extractionResult = await invoice.fromFile(filePath);
|
||||
|
||||
const fileExtractionTime = Date.now() - fileExtractionStart;
|
||||
totalExtractionTime += fileExtractionTime;
|
||||
|
||||
if (extractionResult) {
|
||||
successfulExtractions++;
|
||||
|
||||
tools.log(`✓ ${fileName}: Extracted (${fileSizeKB.toFixed(1)}KB, ${fileExtractionTime}ms)`);
|
||||
|
||||
// Quick validation of extracted content
|
||||
try {
|
||||
const xmlContent = await invoice.toXmlString();
|
||||
if (xmlContent && xmlContent.length > 50) {
|
||||
tools.log(` Content length: ${xmlContent.length} chars`);
|
||||
}
|
||||
} catch (contentError) {
|
||||
tools.log(` ⚠ Content extraction error: ${contentError.message}`);
|
||||
}
|
||||
|
||||
} else {
|
||||
extractionErrors++;
|
||||
tools.log(`⚠ ${fileName}: No XML content extracted`);
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
extractionErrors++;
|
||||
const fileExtractionTime = Date.now() - fileExtractionStart;
|
||||
totalExtractionTime += fileExtractionTime;
|
||||
|
||||
tools.log(`✗ ${fileName}: Extraction failed - ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
// Calculate statistics
|
||||
const successRate = processedFiles > 0 ? (successfulExtractions / processedFiles) * 100 : 0;
|
||||
const averageExtractionTime = processedFiles > 0 ? totalExtractionTime / processedFiles : 0;
|
||||
|
||||
tools.log(`\nZUGFeRD v1 Extraction Summary:`);
|
||||
tools.log(`- Files processed: ${processedFiles}`);
|
||||
tools.log(`- Successful extractions: ${successfulExtractions} (${successRate.toFixed(1)}%)`);
|
||||
tools.log(`- Extraction errors: ${extractionErrors}`);
|
||||
tools.log(`- Average extraction time: ${averageExtractionTime.toFixed(1)}ms`);
|
||||
|
||||
// Performance expectations
|
||||
if (processedFiles > 0) {
|
||||
expect(averageExtractionTime).toBeLessThan(5000); // 5 seconds max per file
|
||||
}
|
||||
|
||||
// We expect at least some extractions to work, but don't require 100% success
|
||||
// as some files might be corrupted or use unsupported PDF features
|
||||
if (processedFiles > 0) {
|
||||
expect(successRate).toBeGreaterThan(0); // At least one file should work
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
tools.log(`ZUGFeRD v1 corpus processing failed: ${error.message}`);
|
||||
throw error;
|
||||
}
|
||||
|
||||
const totalDuration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdf-zugferd-v1-corpus-extraction', totalDuration);
|
||||
|
||||
tools.log(`ZUGFeRD v1 corpus processing completed in ${totalDuration}ms`);
|
||||
});
|
||||
|
||||
tap.test('PDF-02: ZUGFeRD v1 Extraction - Format Validation', async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
try {
|
||||
const zugferdV1Files = await CorpusLoader.getFiles('ZUGFERD_V1');
|
||||
|
||||
if (zugferdV1Files.length === 0) {
|
||||
tools.log('⚠ No ZUGFeRD v1 files found for format validation');
|
||||
return;
|
||||
}
|
||||
|
||||
// Test with first available file for detailed format validation
|
||||
const testFile = zugferdV1Files[0];
|
||||
const fileName = plugins.path.basename(testFile);
|
||||
|
||||
tools.log(`Testing ZUGFeRD v1 format validation with: ${fileName}`);
|
||||
|
||||
const invoice = new EInvoice();
|
||||
|
||||
try {
|
||||
const extractionResult = await invoice.fromFile(testFile);
|
||||
|
||||
if (extractionResult) {
|
||||
const xmlContent = await invoice.toXmlString();
|
||||
|
||||
// ZUGFeRD v1 specific format checks
|
||||
const formatChecks = {
|
||||
hasXmlDeclaration: xmlContent.startsWith('<?xml'),
|
||||
hasZugferdNamespace: xmlContent.includes('urn:ferd:CrossIndustryDocument:invoice:1p0') ||
|
||||
xmlContent.includes('ZUGFeRD') ||
|
||||
xmlContent.includes('FERD'),
|
||||
hasInvoiceElements: xmlContent.includes('<Invoice') ||
|
||||
xmlContent.includes('<CrossIndustryDocument') ||
|
||||
xmlContent.includes('<invoice'),
|
||||
isWellFormed: true // Assume true if we got this far
|
||||
};
|
||||
|
||||
tools.log(`ZUGFeRD v1 Format Validation Results:`);
|
||||
tools.log(`- Has XML Declaration: ${formatChecks.hasXmlDeclaration}`);
|
||||
tools.log(`- Has ZUGFeRD Namespace: ${formatChecks.hasZugferdNamespace}`);
|
||||
tools.log(`- Has Invoice Elements: ${formatChecks.hasInvoiceElements}`);
|
||||
tools.log(`- Is Well-Formed: ${formatChecks.isWellFormed}`);
|
||||
|
||||
// Basic format expectations
|
||||
expect(formatChecks.hasXmlDeclaration).toBe(true);
|
||||
expect(formatChecks.isWellFormed).toBe(true);
|
||||
|
||||
if (formatChecks.hasZugferdNamespace && formatChecks.hasInvoiceElements) {
|
||||
tools.log('✓ ZUGFeRD v1 format validation passed');
|
||||
} else {
|
||||
tools.log('⚠ ZUGFeRD v1 format markers not fully detected');
|
||||
}
|
||||
|
||||
// Test format detection if available
|
||||
if (typeof invoice.detectFormat === 'function') {
|
||||
try {
|
||||
const detectedFormat = await invoice.detectFormat(xmlContent);
|
||||
tools.log(`Detected format: ${detectedFormat}`);
|
||||
|
||||
if (detectedFormat.toLowerCase().includes('zugferd') ||
|
||||
detectedFormat.toLowerCase().includes('cii')) {
|
||||
tools.log('✓ Format detection correctly identified ZUGFeRD/CII');
|
||||
}
|
||||
} catch (detectionError) {
|
||||
tools.log(`Format detection error: ${detectionError.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
tools.log('⚠ No content extracted for format validation');
|
||||
}
|
||||
|
||||
} catch (extractionError) {
|
||||
tools.log(`Format validation extraction failed: ${extractionError.message}`);
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
tools.log(`ZUGFeRD v1 format validation failed: ${error.message}`);
|
||||
}
|
||||
|
||||
const duration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdf-zugferd-v1-format-validation', duration);
|
||||
});
|
||||
|
||||
tap.test('PDF-02: ZUGFeRD v1 Extraction - Error Handling', async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
// Test error handling with various problematic scenarios
|
||||
const errorTestCases = [
|
||||
{
|
||||
name: 'Non-existent file',
|
||||
filePath: '/non/existent/zugferd.pdf',
|
||||
expectedError: true
|
||||
},
|
||||
{
|
||||
name: 'Empty file path',
|
||||
filePath: '',
|
||||
expectedError: true
|
||||
}
|
||||
];
|
||||
|
||||
for (const testCase of errorTestCases) {
|
||||
tools.log(`Testing error handling: ${testCase.name}`);
|
||||
|
||||
try {
|
||||
const invoice = new EInvoice();
|
||||
|
||||
if (testCase.filePath) {
|
||||
const result = await invoice.fromFile(testCase.filePath);
|
||||
|
||||
if (testCase.expectedError) {
|
||||
tools.log(`⚠ Expected error for ${testCase.name} but operation succeeded`);
|
||||
} else {
|
||||
tools.log(`✓ ${testCase.name}: Operation succeeded as expected`);
|
||||
}
|
||||
} else {
|
||||
// Test with empty/invalid path
|
||||
try {
|
||||
await invoice.fromFile(testCase.filePath);
|
||||
if (testCase.expectedError) {
|
||||
tools.log(`⚠ Expected error for ${testCase.name} but no error occurred`);
|
||||
}
|
||||
} catch (error) {
|
||||
if (testCase.expectedError) {
|
||||
tools.log(`✓ ${testCase.name}: Expected error caught - ${error.message}`);
|
||||
} else {
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
if (testCase.expectedError) {
|
||||
tools.log(`✓ ${testCase.name}: Expected error caught - ${error.message}`);
|
||||
expect(error.message).toBeTruthy();
|
||||
} else {
|
||||
tools.log(`✗ ${testCase.name}: Unexpected error - ${error.message}`);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const duration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdf-zugferd-v1-error-handling', duration);
|
||||
});
|
||||
|
||||
tap.test('PDF-02: Performance Summary', async (tools) => {
|
||||
const operations = [
|
||||
'pdf-zugferd-v1-basic-extraction',
|
||||
'pdf-zugferd-v1-corpus-extraction',
|
||||
'pdf-zugferd-v1-format-validation',
|
||||
'pdf-zugferd-v1-error-handling'
|
||||
];
|
||||
|
||||
tools.log(`\n=== ZUGFeRD v1 Extraction 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`);
|
||||
}
|
||||
}
|
||||
|
||||
tools.log(`\nZUGFeRD v1 extraction testing completed.`);
|
||||
});
|
||||
@ -0,0 +1,486 @@
|
||||
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';
|
||||
|
||||
const testTimeout = 300000; // 5 minutes timeout for PDF processing
|
||||
|
||||
// PDF-03: ZUGFeRD v2/Factur-X Extraction
|
||||
// Tests XML extraction from ZUGFeRD v2 and Factur-X PDFs with enhanced format support
|
||||
// and cross-border compatibility (German ZUGFeRD v2 and French Factur-X)
|
||||
|
||||
tap.test('PDF-03: Factur-X Extraction - Basic ZUGFeRD v2 Extraction', async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
try {
|
||||
const zugferdV2Files = await CorpusLoader.getFiles('ZUGFERD_V2');
|
||||
|
||||
if (zugferdV2Files.length === 0) {
|
||||
tools.log('⚠ No ZUGFeRD v2 files found in corpus, skipping basic extraction test');
|
||||
return;
|
||||
}
|
||||
|
||||
const testFile = zugferdV2Files[0];
|
||||
tools.log(`Testing ZUGFeRD v2 extraction with: ${plugins.path.basename(testFile)}`);
|
||||
|
||||
const invoice = new EInvoice();
|
||||
|
||||
// Check file accessibility
|
||||
const fileExists = await plugins.fs.pathExists(testFile);
|
||||
expect(fileExists).toBe(true);
|
||||
|
||||
const fileStats = await plugins.fs.stat(testFile);
|
||||
tools.log(`File size: ${(fileStats.size / 1024).toFixed(1)}KB`);
|
||||
|
||||
// Attempt PDF extraction
|
||||
try {
|
||||
const extractionResult = await invoice.fromFile(testFile);
|
||||
|
||||
if (extractionResult) {
|
||||
tools.log('✓ ZUGFeRD v2 XML extraction successful');
|
||||
|
||||
// Verify extracted content
|
||||
const extractedXml = await invoice.toXmlString();
|
||||
expect(extractedXml).toBeTruthy();
|
||||
expect(extractedXml.length).toBeGreaterThan(100);
|
||||
|
||||
// Check for ZUGFeRD v2/Factur-X characteristics
|
||||
const hasZugferdV2Markers = extractedXml.includes('urn:cen.eu:en16931:2017') ||
|
||||
extractedXml.includes('CrossIndustryInvoice') ||
|
||||
extractedXml.includes('urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100') ||
|
||||
extractedXml.includes('zugferd') ||
|
||||
extractedXml.includes('factur-x');
|
||||
|
||||
if (hasZugferdV2Markers) {
|
||||
tools.log('✓ ZUGFeRD v2/Factur-X format markers detected');
|
||||
} else {
|
||||
tools.log('⚠ ZUGFeRD v2/Factur-X format markers not clearly detected');
|
||||
}
|
||||
|
||||
// Test validation of extracted content
|
||||
try {
|
||||
const validationResult = await invoice.validate();
|
||||
if (validationResult.valid) {
|
||||
tools.log('✓ Extracted ZUGFeRD v2 content passes validation');
|
||||
} else {
|
||||
tools.log(`⚠ Validation issues: ${validationResult.errors?.length || 0} errors`);
|
||||
if (validationResult.errors && validationResult.errors.length > 0) {
|
||||
tools.log(` First error: ${validationResult.errors[0].message}`);
|
||||
}
|
||||
}
|
||||
} catch (validationError) {
|
||||
tools.log(`⚠ Validation failed: ${validationError.message}`);
|
||||
}
|
||||
|
||||
} else {
|
||||
tools.log('⚠ ZUGFeRD v2 extraction returned no result');
|
||||
}
|
||||
|
||||
} catch (extractionError) {
|
||||
tools.log(`⚠ ZUGFeRD v2 extraction failed: ${extractionError.message}`);
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
tools.log(`ZUGFeRD v2 basic extraction test failed: ${error.message}`);
|
||||
}
|
||||
|
||||
const duration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdf-facturx-basic-extraction', duration);
|
||||
});
|
||||
|
||||
tap.test('PDF-03: Factur-X Extraction - Factur-X Specific Testing', async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
try {
|
||||
// Look for Factur-X specific files in corpus
|
||||
const facturxFiles = await CorpusLoader.getFiles('ZUGFERD_V2');
|
||||
|
||||
// Filter for files that might be Factur-X specific
|
||||
const potentialFacturxFiles = facturxFiles.filter(file =>
|
||||
plugins.path.basename(file).toLowerCase().includes('factur') ||
|
||||
plugins.path.basename(file).toLowerCase().includes('france') ||
|
||||
plugins.path.basename(file).toLowerCase().includes('fr')
|
||||
);
|
||||
|
||||
if (potentialFacturxFiles.length === 0) {
|
||||
tools.log('⚠ No specific Factur-X files identified, testing with ZUGFeRD v2 files');
|
||||
// Use first few ZUGFeRD v2 files as they should be compatible
|
||||
potentialFacturxFiles.push(...facturxFiles.slice(0, 2));
|
||||
}
|
||||
|
||||
tools.log(`Testing Factur-X specific features with ${potentialFacturxFiles.length} files`);
|
||||
|
||||
let facturxProcessed = 0;
|
||||
let facturxSuccessful = 0;
|
||||
|
||||
for (const filePath of potentialFacturxFiles) {
|
||||
const fileName = plugins.path.basename(filePath);
|
||||
|
||||
try {
|
||||
facturxProcessed++;
|
||||
|
||||
const invoice = new EInvoice();
|
||||
const extractionResult = await invoice.fromFile(filePath);
|
||||
|
||||
if (extractionResult) {
|
||||
facturxSuccessful++;
|
||||
|
||||
const xmlContent = await invoice.toXmlString();
|
||||
|
||||
// Look for Factur-X specific characteristics
|
||||
const facturxChecks = {
|
||||
hasEN16931Context: xmlContent.includes('urn:cen.eu:en16931:2017'),
|
||||
hasCIINamespace: xmlContent.includes('urn:un:unece:uncefact:data:standard:CrossIndustryInvoice'),
|
||||
hasFacturxGuideline: xmlContent.includes('factur-x') || xmlContent.includes('FACTUR-X'),
|
||||
hasExchangedDocument: xmlContent.includes('ExchangedDocument'),
|
||||
hasSupplyChainTrade: xmlContent.includes('SupplyChainTradeTransaction')
|
||||
};
|
||||
|
||||
tools.log(`${fileName} Factur-X characteristics:`);
|
||||
tools.log(` EN16931 Context: ${facturxChecks.hasEN16931Context}`);
|
||||
tools.log(` CII Namespace: ${facturxChecks.hasCIINamespace}`);
|
||||
tools.log(` Factur-X Guideline: ${facturxChecks.hasFacturxGuideline}`);
|
||||
tools.log(` ExchangedDocument: ${facturxChecks.hasExchangedDocument}`);
|
||||
tools.log(` SupplyChainTrade: ${facturxChecks.hasSupplyChainTrade}`);
|
||||
|
||||
// Basic Factur-X structure validation
|
||||
if (facturxChecks.hasEN16931Context && facturxChecks.hasCIINamespace) {
|
||||
tools.log(` ✓ Valid Factur-X/ZUGFeRD v2 structure detected`);
|
||||
}
|
||||
|
||||
} else {
|
||||
tools.log(`⚠ ${fileName}: No XML content extracted`);
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
tools.log(`✗ ${fileName}: Extraction failed - ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
const facturxSuccessRate = facturxProcessed > 0 ? (facturxSuccessful / facturxProcessed) * 100 : 0;
|
||||
|
||||
tools.log(`\nFactur-X Processing Summary:`);
|
||||
tools.log(`- Files processed: ${facturxProcessed}`);
|
||||
tools.log(`- Successful extractions: ${facturxSuccessful} (${facturxSuccessRate.toFixed(1)}%)`);
|
||||
|
||||
if (facturxProcessed > 0) {
|
||||
expect(facturxSuccessRate).toBeGreaterThan(0);
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
tools.log(`Factur-X specific testing failed: ${error.message}`);
|
||||
}
|
||||
|
||||
const duration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdf-facturx-specific-testing', duration);
|
||||
});
|
||||
|
||||
tap.test('PDF-03: Factur-X Extraction - Corpus Performance Analysis', { timeout: testTimeout }, async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
let totalProcessed = 0;
|
||||
let totalSuccessful = 0;
|
||||
let totalExtractionTime = 0;
|
||||
const fileSizePerformance = [];
|
||||
|
||||
try {
|
||||
const zugferdV2Files = await CorpusLoader.getFiles('ZUGFERD_V2');
|
||||
tools.log(`Processing ${zugferdV2Files.length} ZUGFeRD v2/Factur-X files for performance analysis`);
|
||||
|
||||
if (zugferdV2Files.length === 0) {
|
||||
tools.log('⚠ No ZUGFeRD v2/Factur-X files found in corpus');
|
||||
return;
|
||||
}
|
||||
|
||||
// Process subset for performance analysis
|
||||
const filesToProcess = zugferdV2Files.slice(0, Math.min(10, zugferdV2Files.length));
|
||||
|
||||
for (const filePath of filesToProcess) {
|
||||
const fileName = plugins.path.basename(filePath);
|
||||
const fileExtractionStart = Date.now();
|
||||
|
||||
try {
|
||||
totalProcessed++;
|
||||
|
||||
// Get file size for performance correlation
|
||||
const fileStats = await plugins.fs.stat(filePath);
|
||||
const fileSizeKB = fileStats.size / 1024;
|
||||
|
||||
const invoice = new EInvoice();
|
||||
const extractionResult = await invoice.fromFile(filePath);
|
||||
|
||||
const fileExtractionTime = Date.now() - fileExtractionStart;
|
||||
totalExtractionTime += fileExtractionTime;
|
||||
|
||||
if (extractionResult) {
|
||||
totalSuccessful++;
|
||||
|
||||
// Record size vs performance data
|
||||
fileSizePerformance.push({
|
||||
fileName,
|
||||
sizeKB: fileSizeKB,
|
||||
extractionTimeMs: fileExtractionTime,
|
||||
timePerKB: fileExtractionTime / fileSizeKB
|
||||
});
|
||||
|
||||
tools.log(`✓ ${fileName}: ${fileSizeKB.toFixed(1)}KB → ${fileExtractionTime}ms (${(fileExtractionTime/fileSizeKB).toFixed(2)}ms/KB)`);
|
||||
|
||||
// Quick content verification
|
||||
const xmlContent = await invoice.toXmlString();
|
||||
if (xmlContent.length < 100) {
|
||||
tools.log(` ⚠ Suspiciously short XML content: ${xmlContent.length} chars`);
|
||||
}
|
||||
|
||||
} else {
|
||||
tools.log(`⚠ ${fileName}: Extraction failed (${fileSizeKB.toFixed(1)}KB, ${fileExtractionTime}ms)`);
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
const fileExtractionTime = Date.now() - fileExtractionStart;
|
||||
totalExtractionTime += fileExtractionTime;
|
||||
tools.log(`✗ ${fileName}: Error after ${fileExtractionTime}ms - ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
// Performance analysis
|
||||
const successRate = totalProcessed > 0 ? (totalSuccessful / totalProcessed) * 100 : 0;
|
||||
const averageExtractionTime = totalProcessed > 0 ? totalExtractionTime / totalProcessed : 0;
|
||||
|
||||
tools.log(`\nZUGFeRD v2/Factur-X Performance Analysis:`);
|
||||
tools.log(`- Files processed: ${totalProcessed}`);
|
||||
tools.log(`- Success rate: ${successRate.toFixed(1)}%`);
|
||||
tools.log(`- Average extraction time: ${averageExtractionTime.toFixed(1)}ms`);
|
||||
|
||||
if (fileSizePerformance.length > 0) {
|
||||
const avgTimePerKB = fileSizePerformance.reduce((sum, item) => sum + item.timePerKB, 0) / fileSizePerformance.length;
|
||||
const avgFileSize = fileSizePerformance.reduce((sum, item) => sum + item.sizeKB, 0) / fileSizePerformance.length;
|
||||
|
||||
tools.log(`- Average file size: ${avgFileSize.toFixed(1)}KB`);
|
||||
tools.log(`- Average time per KB: ${avgTimePerKB.toFixed(2)}ms/KB`);
|
||||
|
||||
// Find performance outliers
|
||||
const sortedByTime = [...fileSizePerformance].sort((a, b) => b.extractionTimeMs - a.extractionTimeMs);
|
||||
if (sortedByTime.length > 0) {
|
||||
tools.log(`- Slowest file: ${sortedByTime[0].fileName} (${sortedByTime[0].extractionTimeMs}ms)`);
|
||||
tools.log(`- Fastest file: ${sortedByTime[sortedByTime.length-1].fileName} (${sortedByTime[sortedByTime.length-1].extractionTimeMs}ms)`);
|
||||
}
|
||||
|
||||
// Performance expectations
|
||||
expect(avgTimePerKB).toBeLessThan(50); // 50ms per KB max
|
||||
expect(averageExtractionTime).toBeLessThan(3000); // 3 seconds max average
|
||||
}
|
||||
|
||||
// Success rate expectations
|
||||
if (totalProcessed > 0) {
|
||||
expect(successRate).toBeGreaterThan(0); // At least one should work
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
tools.log(`Corpus performance analysis failed: ${error.message}`);
|
||||
throw error;
|
||||
}
|
||||
|
||||
const totalDuration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdf-facturx-corpus-performance', totalDuration);
|
||||
|
||||
tools.log(`Performance analysis completed in ${totalDuration}ms`);
|
||||
});
|
||||
|
||||
tap.test('PDF-03: Factur-X Extraction - Profile Detection', async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
try {
|
||||
const zugferdV2Files = await CorpusLoader.getFiles('ZUGFERD_V2');
|
||||
|
||||
if (zugferdV2Files.length === 0) {
|
||||
tools.log('⚠ No ZUGFeRD v2/Factur-X files found for profile detection');
|
||||
return;
|
||||
}
|
||||
|
||||
// Test profile detection with a sample of files
|
||||
const sampleFiles = zugferdV2Files.slice(0, 3);
|
||||
const profileStats = {
|
||||
'MINIMUM': 0,
|
||||
'BASIC': 0,
|
||||
'COMFORT': 0,
|
||||
'EXTENDED': 0,
|
||||
'FACTUR-X': 0,
|
||||
'UNKNOWN': 0
|
||||
};
|
||||
|
||||
tools.log(`Testing profile detection with ${sampleFiles.length} files`);
|
||||
|
||||
for (const filePath of sampleFiles) {
|
||||
const fileName = plugins.path.basename(filePath);
|
||||
|
||||
try {
|
||||
const invoice = new EInvoice();
|
||||
const extractionResult = await invoice.fromFile(filePath);
|
||||
|
||||
if (extractionResult) {
|
||||
const xmlContent = await invoice.toXmlString();
|
||||
|
||||
// Detect ZUGFeRD/Factur-X profile from XML content
|
||||
let detectedProfile = 'UNKNOWN';
|
||||
|
||||
if (xmlContent.includes('urn:cen.eu:en16931:2017#compliant#urn:zugferd.de:2p1:minimum')) {
|
||||
detectedProfile = 'MINIMUM';
|
||||
} else if (xmlContent.includes('urn:cen.eu:en16931:2017#compliant#urn:zugferd.de:2p1:basic')) {
|
||||
detectedProfile = 'BASIC';
|
||||
} else if (xmlContent.includes('urn:cen.eu:en16931:2017#compliant#urn:zugferd.de:2p1:comfort')) {
|
||||
detectedProfile = 'COMFORT';
|
||||
} else if (xmlContent.includes('urn:cen.eu:en16931:2017#compliant#urn:zugferd.de:2p1:extended')) {
|
||||
detectedProfile = 'EXTENDED';
|
||||
} else if (xmlContent.includes('urn:cen.eu:en16931:2017#conformant#urn:factur-x.eu:1p0:')) {
|
||||
detectedProfile = 'FACTUR-X';
|
||||
} else if (xmlContent.includes('urn:cen.eu:en16931:2017')) {
|
||||
detectedProfile = 'EN16931'; // Generic EN16931 compliance
|
||||
}
|
||||
|
||||
profileStats[detectedProfile] = (profileStats[detectedProfile] || 0) + 1;
|
||||
|
||||
tools.log(`${fileName}: Profile detected - ${detectedProfile}`);
|
||||
|
||||
// Additional profile-specific checks
|
||||
if (detectedProfile !== 'UNKNOWN') {
|
||||
const hasMinimumFields = xmlContent.includes('ExchangedDocument') &&
|
||||
xmlContent.includes('SupplyChainTradeTransaction');
|
||||
const hasComfortFields = xmlContent.includes('ApplicableHeaderTradeAgreement') &&
|
||||
xmlContent.includes('ApplicableHeaderTradeDelivery');
|
||||
const hasExtendedFields = xmlContent.includes('IncludedSupplyChainTradeLineItem');
|
||||
|
||||
tools.log(` Minimum fields: ${hasMinimumFields}`);
|
||||
tools.log(` Comfort fields: ${hasComfortFields}`);
|
||||
tools.log(` Extended fields: ${hasExtendedFields}`);
|
||||
}
|
||||
|
||||
} else {
|
||||
tools.log(`⚠ ${fileName}: No content for profile detection`);
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
tools.log(`✗ ${fileName}: Profile detection failed - ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
tools.log(`\nProfile Detection Summary:`);
|
||||
for (const [profile, count] of Object.entries(profileStats)) {
|
||||
if (count > 0) {
|
||||
tools.log(`- ${profile}: ${count} files`);
|
||||
}
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
tools.log(`Profile detection failed: ${error.message}`);
|
||||
}
|
||||
|
||||
const duration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdf-facturx-profile-detection', duration);
|
||||
});
|
||||
|
||||
tap.test('PDF-03: Factur-X Extraction - Error Recovery', async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
// Test error recovery with problematic PDF files
|
||||
const errorTestCases = [
|
||||
{
|
||||
name: 'Non-PDF file with PDF extension',
|
||||
createFile: async () => {
|
||||
const tempPath = plugins.path.join(process.cwd(), '.nogit', 'temp-fake.pdf');
|
||||
await plugins.fs.ensureDir(plugins.path.dirname(tempPath));
|
||||
await plugins.fs.writeFile(tempPath, 'This is not a PDF file');
|
||||
return tempPath;
|
||||
},
|
||||
expectedError: true
|
||||
},
|
||||
{
|
||||
name: 'Empty PDF file',
|
||||
createFile: async () => {
|
||||
const tempPath = plugins.path.join(process.cwd(), '.nogit', 'temp-empty.pdf');
|
||||
await plugins.fs.ensureDir(plugins.path.dirname(tempPath));
|
||||
await plugins.fs.writeFile(tempPath, '');
|
||||
return tempPath;
|
||||
},
|
||||
expectedError: true
|
||||
},
|
||||
{
|
||||
name: 'PDF header only',
|
||||
createFile: async () => {
|
||||
const tempPath = plugins.path.join(process.cwd(), '.nogit', 'temp-header-only.pdf');
|
||||
await plugins.fs.ensureDir(plugins.path.dirname(tempPath));
|
||||
await plugins.fs.writeFile(tempPath, '%PDF-1.4\n');
|
||||
return tempPath;
|
||||
},
|
||||
expectedError: true
|
||||
}
|
||||
];
|
||||
|
||||
for (const testCase of errorTestCases) {
|
||||
tools.log(`Testing error recovery: ${testCase.name}`);
|
||||
|
||||
let tempFilePath = null;
|
||||
|
||||
try {
|
||||
if (testCase.createFile) {
|
||||
tempFilePath = await testCase.createFile();
|
||||
|
||||
const invoice = new EInvoice();
|
||||
const result = await invoice.fromFile(tempFilePath);
|
||||
|
||||
if (testCase.expectedError) {
|
||||
if (result) {
|
||||
tools.log(`⚠ Expected error for ${testCase.name} but extraction succeeded`);
|
||||
} else {
|
||||
tools.log(`✓ ${testCase.name}: Gracefully handled (no result)`);
|
||||
}
|
||||
} else {
|
||||
tools.log(`✓ ${testCase.name}: Operation succeeded as expected`);
|
||||
}
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
if (testCase.expectedError) {
|
||||
tools.log(`✓ ${testCase.name}: Expected error caught - ${error.message}`);
|
||||
expect(error.message).toBeTruthy();
|
||||
} else {
|
||||
tools.log(`✗ ${testCase.name}: Unexpected error - ${error.message}`);
|
||||
throw error;
|
||||
}
|
||||
} finally {
|
||||
// Clean up temp file
|
||||
if (tempFilePath) {
|
||||
try {
|
||||
await plugins.fs.remove(tempFilePath);
|
||||
} catch (cleanupError) {
|
||||
tools.log(`Warning: Failed to clean up ${tempFilePath}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const duration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdf-facturx-error-recovery', duration);
|
||||
});
|
||||
|
||||
tap.test('PDF-03: Performance Summary', async (tools) => {
|
||||
const operations = [
|
||||
'pdf-facturx-basic-extraction',
|
||||
'pdf-facturx-specific-testing',
|
||||
'pdf-facturx-corpus-performance',
|
||||
'pdf-facturx-profile-detection',
|
||||
'pdf-facturx-error-recovery'
|
||||
];
|
||||
|
||||
tools.log(`\n=== ZUGFeRD v2/Factur-X Extraction 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`);
|
||||
}
|
||||
}
|
||||
|
||||
tools.log(`\nZUGFeRD v2/Factur-X extraction testing completed.`);
|
||||
});
|
||||
643
test/suite/einvoice_pdf-operations/test.pdf-04.xml-embedding.ts
Normal file
643
test/suite/einvoice_pdf-operations/test.pdf-04.xml-embedding.ts
Normal file
@ -0,0 +1,643 @@
|
||||
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';
|
||||
|
||||
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();
|
||||
|
||||
// Test basic XML 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 invoice = new EInvoice();
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
} 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');
|
||||
}
|
||||
}
|
||||
|
||||
} 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));
|
||||
|
||||
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');
|
||||
}
|
||||
|
||||
} else {
|
||||
tools.log('⚠ Embedding into existing PDF not supported');
|
||||
}
|
||||
|
||||
} catch (embeddingError) {
|
||||
tools.log(`⚠ Embedding into existing PDF failed: ${embeddingError.message}`);
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
tools.log(`Embedding into existing PDF test failed: ${error.message}`);
|
||||
}
|
||||
|
||||
const duration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdf-embedding-existing', duration);
|
||||
});
|
||||
|
||||
tap.test('PDF-04: XML Embedding - Multiple Format Embedding', async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
// 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'
|
||||
}
|
||||
];
|
||||
|
||||
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}`);
|
||||
}
|
||||
}
|
||||
|
||||
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 performanceResults = [];
|
||||
|
||||
for (const sizeTest of sizeTests) {
|
||||
tools.log(`Testing embedding performance: ${sizeTest.name}`);
|
||||
|
||||
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();
|
||||
|
||||
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`);
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
tools.log(` ✗ ${sizeTest.name} failed: ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
// Analyze performance results
|
||||
if (performanceResults.length > 0) {
|
||||
tools.log(`\nEmbedding Performance Analysis:`);
|
||||
|
||||
const avgTimePerKB = performanceResults.reduce((sum, r) => sum + r.timePerKB, 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`);
|
||||
|
||||
// Performance expectations
|
||||
expect(avgTimePerKB).toBeLessThan(100); // 100ms per KB max
|
||||
expect(maxTime).toBeLessThan(10000); // 10 seconds max for any size
|
||||
}
|
||||
|
||||
const duration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdf-embedding-performance', duration);
|
||||
});
|
||||
|
||||
tap.test('PDF-04: Performance Summary', async (tools) => {
|
||||
const operations = [
|
||||
'pdf-embedding-basic',
|
||||
'pdf-embedding-existing',
|
||||
'pdf-embedding-multiple-formats',
|
||||
'pdf-embedding-metadata',
|
||||
'pdf-embedding-performance'
|
||||
];
|
||||
|
||||
tools.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`);
|
||||
}
|
||||
}
|
||||
|
||||
tools.log(`\nXML embedding testing completed.`);
|
||||
});
|
||||
790
test/suite/einvoice_pdf-operations/test.pdf-05.pdfa3-creation.ts
Normal file
790
test/suite/einvoice_pdf-operations/test.pdf-05.pdfa3-creation.ts
Normal file
@ -0,0 +1,790 @@
|
||||
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';
|
||||
|
||||
const testTimeout = 300000; // 5 minutes timeout for PDF processing
|
||||
|
||||
// PDF-05: PDF/A-3 Creation
|
||||
// Tests creation of PDF/A-3 compliant documents with embedded XML attachments
|
||||
// according to ISO 19005-3 standard and ZUGFeRD/Factur-X requirements
|
||||
|
||||
tap.test('PDF-05: PDF/A-3 Creation - Basic PDF/A-3 Generation', async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
// Test basic PDF/A-3 creation functionality
|
||||
try {
|
||||
const sampleXml = `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
|
||||
<ID>PDFA3-TEST-001</ID>
|
||||
<IssueDate>2024-01-01</IssueDate>
|
||||
<InvoiceTypeCode>380</InvoiceTypeCode>
|
||||
<DocumentCurrencyCode>EUR</DocumentCurrencyCode>
|
||||
<AccountingSupplierParty>
|
||||
<Party>
|
||||
<PartyName>
|
||||
<Name>PDF/A-3 Test Supplier</Name>
|
||||
</PartyName>
|
||||
<PostalAddress>
|
||||
<StreetName>Test Street 123</StreetName>
|
||||
<CityName>Test City</CityName>
|
||||
<PostalZone>12345</PostalZone>
|
||||
<Country>
|
||||
<IdentificationCode>DE</IdentificationCode>
|
||||
</Country>
|
||||
</PostalAddress>
|
||||
</Party>
|
||||
</AccountingSupplierParty>
|
||||
<AccountingCustomerParty>
|
||||
<Party>
|
||||
<PartyName>
|
||||
<Name>PDF/A-3 Test Customer</Name>
|
||||
</PartyName>
|
||||
</Party>
|
||||
</AccountingCustomerParty>
|
||||
<InvoiceLine>
|
||||
<ID>1</ID>
|
||||
<InvoicedQuantity unitCode="C62">1</InvoicedQuantity>
|
||||
<LineExtensionAmount currencyID="EUR">100.00</LineExtensionAmount>
|
||||
<Item>
|
||||
<Name>PDF/A-3 Test Item</Name>
|
||||
</Item>
|
||||
<Price>
|
||||
<PriceAmount currencyID="EUR">100.00</PriceAmount>
|
||||
</Price>
|
||||
</InvoiceLine>
|
||||
<TaxTotal>
|
||||
<TaxAmount currencyID="EUR">19.00</TaxAmount>
|
||||
</TaxTotal>
|
||||
<LegalMonetaryTotal>
|
||||
<LineExtensionAmount currencyID="EUR">100.00</LineExtensionAmount>
|
||||
<TaxExclusiveAmount currencyID="EUR">100.00</TaxExclusiveAmount>
|
||||
<TaxInclusiveAmount currencyID="EUR">119.00</TaxInclusiveAmount>
|
||||
<PayableAmount currencyID="EUR">119.00</PayableAmount>
|
||||
</LegalMonetaryTotal>
|
||||
</Invoice>`;
|
||||
|
||||
const invoice = new EInvoice();
|
||||
const parseResult = await invoice.fromXmlString(sampleXml);
|
||||
expect(parseResult).toBeTruthy();
|
||||
|
||||
// Test PDF/A-3 creation if supported
|
||||
if (typeof invoice.createPdfA3 === 'function') {
|
||||
tools.log('Testing PDF/A-3 creation...');
|
||||
|
||||
const outputPath = plugins.path.join(process.cwd(), '.nogit', 'test-pdfa3-basic.pdf');
|
||||
await plugins.fs.ensureDir(plugins.path.dirname(outputPath));
|
||||
|
||||
try {
|
||||
const pdfA3Options = {
|
||||
outputPath: outputPath,
|
||||
xmlContent: sampleXml,
|
||||
attachmentName: 'ZUGFeRD-invoice.xml',
|
||||
pdfA3Compliance: true,
|
||||
title: 'Electronic Invoice PDFA3-TEST-001',
|
||||
author: 'EInvoice Test Suite',
|
||||
subject: 'PDF/A-3 compliant invoice',
|
||||
keywords: 'invoice, electronic, PDF/A-3, ZUGFeRD'
|
||||
};
|
||||
|
||||
const creationResult = await invoice.createPdfA3(pdfA3Options);
|
||||
|
||||
if (creationResult) {
|
||||
tools.log('✓ PDF/A-3 creation completed');
|
||||
|
||||
// Verify output file
|
||||
const outputExists = await plugins.fs.pathExists(outputPath);
|
||||
if (outputExists) {
|
||||
const outputStats = await plugins.fs.stat(outputPath);
|
||||
tools.log(`✓ PDF/A-3 file created: ${(outputStats.size / 1024).toFixed(1)}KB`);
|
||||
|
||||
// Basic PDF validation (check if it starts with PDF header)
|
||||
const pdfHeader = await plugins.fs.readFile(outputPath, { encoding: 'binary' });
|
||||
if (pdfHeader.startsWith('%PDF-')) {
|
||||
tools.log('✓ Valid PDF header detected');
|
||||
|
||||
// Check for PDF/A-3 markers if possible
|
||||
const pdfContent = pdfHeader.substring(0, 1024);
|
||||
if (pdfContent.includes('PDF/A-3') || pdfContent.includes('PDFA-3')) {
|
||||
tools.log('✓ PDF/A-3 markers detected');
|
||||
}
|
||||
} else {
|
||||
tools.log('⚠ Invalid PDF header');
|
||||
}
|
||||
|
||||
// Test XML extraction from created PDF/A-3
|
||||
try {
|
||||
const extractionInvoice = new EInvoice();
|
||||
const extractionResult = await extractionInvoice.fromFile(outputPath);
|
||||
|
||||
if (extractionResult) {
|
||||
const extractedXml = await extractionInvoice.toXmlString();
|
||||
if (extractedXml.includes('PDFA3-TEST-001')) {
|
||||
tools.log('✓ XML successfully extracted from PDF/A-3');
|
||||
} else {
|
||||
tools.log('⚠ Extracted XML does not contain expected content');
|
||||
}
|
||||
} else {
|
||||
tools.log('⚠ Could not extract XML from created PDF/A-3');
|
||||
}
|
||||
} catch (extractionError) {
|
||||
tools.log(`⚠ XML extraction test failed: ${extractionError.message}`);
|
||||
}
|
||||
|
||||
// Clean up
|
||||
await plugins.fs.remove(outputPath);
|
||||
|
||||
} else {
|
||||
tools.log('⚠ PDF/A-3 file not created');
|
||||
}
|
||||
|
||||
} else {
|
||||
tools.log('⚠ PDF/A-3 creation returned no result');
|
||||
}
|
||||
|
||||
} catch (creationError) {
|
||||
tools.log(`⚠ PDF/A-3 creation failed: ${creationError.message}`);
|
||||
}
|
||||
|
||||
} else if (typeof invoice.toPdf === 'function') {
|
||||
tools.log('⚠ Specific PDF/A-3 creation not available, testing general PDF creation...');
|
||||
|
||||
try {
|
||||
const pdfResult = await invoice.toPdf({
|
||||
pdfACompliance: 'PDF/A-3'
|
||||
});
|
||||
|
||||
if (pdfResult) {
|
||||
tools.log('✓ General PDF creation with PDF/A-3 compliance completed');
|
||||
}
|
||||
} catch (pdfError) {
|
||||
tools.log(`⚠ General PDF creation failed: ${pdfError.message}`);
|
||||
}
|
||||
|
||||
} else {
|
||||
tools.log('⚠ PDF/A-3 creation functionality not available');
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
tools.log(`Basic PDF/A-3 creation test failed: ${error.message}`);
|
||||
}
|
||||
|
||||
const duration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdfa3-creation-basic', duration);
|
||||
});
|
||||
|
||||
tap.test('PDF-05: PDF/A-3 Creation - Compliance Levels', async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
// Test different PDF/A-3 compliance levels (A, B, U)
|
||||
const complianceLevels = [
|
||||
{
|
||||
level: 'PDF/A-3B',
|
||||
description: 'PDF/A-3 Level B (visual appearance)',
|
||||
strictness: 'medium'
|
||||
},
|
||||
{
|
||||
level: 'PDF/A-3A',
|
||||
description: 'PDF/A-3 Level A (accessibility)',
|
||||
strictness: 'high'
|
||||
},
|
||||
{
|
||||
level: 'PDF/A-3U',
|
||||
description: 'PDF/A-3 Level U (Unicode)',
|
||||
strictness: 'medium'
|
||||
}
|
||||
];
|
||||
|
||||
const testXml = `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
|
||||
<ID>COMPLIANCE-TEST-001</ID>
|
||||
<IssueDate>2024-01-01</IssueDate>
|
||||
<InvoiceTypeCode>380</InvoiceTypeCode>
|
||||
<DocumentCurrencyCode>EUR</DocumentCurrencyCode>
|
||||
<LegalMonetaryTotal>
|
||||
<PayableAmount currencyID="EUR">100.00</PayableAmount>
|
||||
</LegalMonetaryTotal>
|
||||
</Invoice>`;
|
||||
|
||||
for (const compliance of complianceLevels) {
|
||||
tools.log(`Testing ${compliance.description}...`);
|
||||
|
||||
try {
|
||||
const invoice = new EInvoice();
|
||||
await invoice.fromXmlString(testXml);
|
||||
|
||||
if (typeof invoice.createPdfA3 === 'function') {
|
||||
const outputPath = plugins.path.join(process.cwd(), '.nogit', `test-${compliance.level.toLowerCase().replace(/\//g, '-')}.pdf`);
|
||||
await plugins.fs.ensureDir(plugins.path.dirname(outputPath));
|
||||
|
||||
const complianceOptions = {
|
||||
outputPath: outputPath,
|
||||
xmlContent: testXml,
|
||||
attachmentName: 'invoice.xml',
|
||||
complianceLevel: compliance.level,
|
||||
title: `${compliance.level} Test Invoice`,
|
||||
validateCompliance: true
|
||||
};
|
||||
|
||||
try {
|
||||
const creationResult = await invoice.createPdfA3(complianceOptions);
|
||||
|
||||
if (creationResult) {
|
||||
tools.log(`✓ ${compliance.level} creation completed`);
|
||||
|
||||
const outputExists = await plugins.fs.pathExists(outputPath);
|
||||
if (outputExists) {
|
||||
const outputStats = await plugins.fs.stat(outputPath);
|
||||
tools.log(` File size: ${(outputStats.size / 1024).toFixed(1)}KB`);
|
||||
|
||||
// Basic compliance validation
|
||||
const pdfContent = await plugins.fs.readFile(outputPath, { encoding: 'binary' });
|
||||
const headerSection = pdfContent.substring(0, 2048);
|
||||
|
||||
// Look for PDF/A compliance indicators
|
||||
if (headerSection.includes('PDF/A-3') ||
|
||||
headerSection.includes('PDFA-3') ||
|
||||
headerSection.includes(compliance.level)) {
|
||||
tools.log(` ✓ ${compliance.level} compliance indicators found`);
|
||||
} else {
|
||||
tools.log(` ⚠ ${compliance.level} compliance indicators not clearly detected`);
|
||||
}
|
||||
|
||||
// Clean up
|
||||
await plugins.fs.remove(outputPath);
|
||||
|
||||
} else {
|
||||
tools.log(` ⚠ ${compliance.level} file not created`);
|
||||
}
|
||||
|
||||
} else {
|
||||
tools.log(`⚠ ${compliance.level} creation returned no result`);
|
||||
}
|
||||
|
||||
} catch (complianceError) {
|
||||
tools.log(`⚠ ${compliance.level} creation failed: ${complianceError.message}`);
|
||||
}
|
||||
|
||||
} else {
|
||||
tools.log(`⚠ ${compliance.level} creation not supported`);
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
tools.log(`✗ ${compliance.level} test failed: ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
const duration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdfa3-creation-compliance-levels', duration);
|
||||
});
|
||||
|
||||
tap.test('PDF-05: PDF/A-3 Creation - ZUGFeRD Profile Creation', async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
// Test PDF/A-3 creation with specific ZUGFeRD/Factur-X profiles
|
||||
const zugferdProfiles = [
|
||||
{
|
||||
profile: 'MINIMUM',
|
||||
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#compliant#urn:zugferd.de:2p1:minimum</ID>
|
||||
</GuidelineSpecifiedDocumentContextParameter>
|
||||
</ExchangedDocumentContext>
|
||||
<ExchangedDocument>
|
||||
<ID>ZUGFERD-MIN-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>`
|
||||
},
|
||||
{
|
||||
profile: 'BASIC',
|
||||
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#compliant#urn:zugferd.de:2p1:basic</ID>
|
||||
</GuidelineSpecifiedDocumentContextParameter>
|
||||
</ExchangedDocumentContext>
|
||||
<ExchangedDocument>
|
||||
<ID>ZUGFERD-BASIC-001</ID>
|
||||
<TypeCode>380</TypeCode>
|
||||
<IssueDateTime>
|
||||
<DateTimeString format="102">20240101</DateTimeString>
|
||||
</IssueDateTime>
|
||||
</ExchangedDocument>
|
||||
<SupplyChainTradeTransaction>
|
||||
<ApplicableHeaderTradeAgreement>
|
||||
<SellerTradeParty>
|
||||
<Name>ZUGFeRD Test Supplier</Name>
|
||||
</SellerTradeParty>
|
||||
<BuyerTradeParty>
|
||||
<Name>ZUGFeRD Test Customer</Name>
|
||||
</BuyerTradeParty>
|
||||
</ApplicableHeaderTradeAgreement>
|
||||
<ApplicableHeaderTradeSettlement>
|
||||
<InvoiceCurrencyCode>EUR</InvoiceCurrencyCode>
|
||||
<SpecifiedTradeSettlementHeaderMonetarySummation>
|
||||
<TaxBasisTotalAmount>100.00</TaxBasisTotalAmount>
|
||||
<TaxTotalAmount currencyID="EUR">19.00</TaxTotalAmount>
|
||||
<GrandTotalAmount>119.00</GrandTotalAmount>
|
||||
<DuePayableAmount>119.00</DuePayableAmount>
|
||||
</SpecifiedTradeSettlementHeaderMonetarySummation>
|
||||
</ApplicableHeaderTradeSettlement>
|
||||
</SupplyChainTradeTransaction>
|
||||
</CrossIndustryInvoice>`
|
||||
},
|
||||
{
|
||||
profile: 'COMFORT',
|
||||
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#compliant#urn:zugferd.de:2p1:comfort</ID>
|
||||
</GuidelineSpecifiedDocumentContextParameter>
|
||||
</ExchangedDocumentContext>
|
||||
<ExchangedDocument>
|
||||
<ID>ZUGFERD-COMFORT-001</ID>
|
||||
<TypeCode>380</TypeCode>
|
||||
<IssueDateTime>
|
||||
<DateTimeString format="102">20240101</DateTimeString>
|
||||
</IssueDateTime>
|
||||
</ExchangedDocument>
|
||||
<SupplyChainTradeTransaction>
|
||||
<IncludedSupplyChainTradeLineItem>
|
||||
<AssociatedDocumentLineDocument>
|
||||
<LineID>1</LineID>
|
||||
</AssociatedDocumentLineDocument>
|
||||
<SpecifiedTradeProduct>
|
||||
<Name>ZUGFeRD Test Product</Name>
|
||||
</SpecifiedTradeProduct>
|
||||
<SpecifiedLineTradeAgreement>
|
||||
<NetPriceProductTradePrice>
|
||||
<ChargeAmount>100.00</ChargeAmount>
|
||||
</NetPriceProductTradePrice>
|
||||
</SpecifiedLineTradeAgreement>
|
||||
<SpecifiedLineTradeSettlement>
|
||||
<SpecifiedTradeSettlementLineMonetarySummation>
|
||||
<LineTotalAmount>100.00</LineTotalAmount>
|
||||
</SpecifiedTradeSettlementLineMonetarySummation>
|
||||
</SpecifiedLineTradeSettlement>
|
||||
</IncludedSupplyChainTradeLineItem>
|
||||
<ApplicableHeaderTradeSettlement>
|
||||
<InvoiceCurrencyCode>EUR</InvoiceCurrencyCode>
|
||||
<SpecifiedTradeSettlementHeaderMonetarySummation>
|
||||
<LineTotalAmount>100.00</LineTotalAmount>
|
||||
<TaxBasisTotalAmount>100.00</TaxBasisTotalAmount>
|
||||
<TaxTotalAmount currencyID="EUR">19.00</TaxTotalAmount>
|
||||
<GrandTotalAmount>119.00</GrandTotalAmount>
|
||||
<DuePayableAmount>119.00</DuePayableAmount>
|
||||
</SpecifiedTradeSettlementHeaderMonetarySummation>
|
||||
</ApplicableHeaderTradeSettlement>
|
||||
</SupplyChainTradeTransaction>
|
||||
</CrossIndustryInvoice>`
|
||||
}
|
||||
];
|
||||
|
||||
for (const zugferdTest of zugferdProfiles) {
|
||||
tools.log(`Testing ZUGFeRD ${zugferdTest.profile} profile PDF/A-3 creation...`);
|
||||
|
||||
try {
|
||||
const invoice = new EInvoice();
|
||||
await invoice.fromXmlString(zugferdTest.xml);
|
||||
|
||||
if (typeof invoice.createPdfA3 === 'function') {
|
||||
const outputPath = plugins.path.join(process.cwd(), '.nogit', `test-zugferd-${zugferdTest.profile.toLowerCase()}.pdf`);
|
||||
await plugins.fs.ensureDir(plugins.path.dirname(outputPath));
|
||||
|
||||
const zugferdOptions = {
|
||||
outputPath: outputPath,
|
||||
xmlContent: zugferdTest.xml,
|
||||
attachmentName: 'ZUGFeRD-invoice.xml',
|
||||
zugferdProfile: zugferdTest.profile,
|
||||
zugferdVersion: '2.1',
|
||||
complianceLevel: 'PDF/A-3B',
|
||||
title: `ZUGFeRD ${zugferdTest.profile} Invoice`,
|
||||
conformanceLevel: 'PDFA_3B'
|
||||
};
|
||||
|
||||
try {
|
||||
const creationResult = await invoice.createPdfA3(zugferdOptions);
|
||||
|
||||
if (creationResult) {
|
||||
tools.log(`✓ ZUGFeRD ${zugferdTest.profile} PDF/A-3 creation completed`);
|
||||
|
||||
const outputExists = await plugins.fs.pathExists(outputPath);
|
||||
if (outputExists) {
|
||||
const outputStats = await plugins.fs.stat(outputPath);
|
||||
tools.log(` File size: ${(outputStats.size / 1024).toFixed(1)}KB`);
|
||||
|
||||
// Test round-trip (extraction from created PDF)
|
||||
try {
|
||||
const extractionInvoice = new EInvoice();
|
||||
const extractionResult = await extractionInvoice.fromFile(outputPath);
|
||||
|
||||
if (extractionResult) {
|
||||
const extractedXml = await extractionInvoice.toXmlString();
|
||||
const expectedId = `ZUGFERD-${zugferdTest.profile}-001`;
|
||||
|
||||
if (extractedXml.includes(expectedId)) {
|
||||
tools.log(` ✓ Round-trip successful - extracted XML contains ${expectedId}`);
|
||||
} else {
|
||||
tools.log(` ⚠ Round-trip issue - expected ID ${expectedId} not found`);
|
||||
}
|
||||
|
||||
// Check for profile-specific elements
|
||||
if (zugferdTest.profile === 'COMFORT' && extractedXml.includes('IncludedSupplyChainTradeLineItem')) {
|
||||
tools.log(` ✓ COMFORT profile line items preserved`);
|
||||
}
|
||||
|
||||
} else {
|
||||
tools.log(` ⚠ Round-trip failed - could not extract XML`);
|
||||
}
|
||||
} catch (extractionError) {
|
||||
tools.log(` ⚠ Round-trip test failed: ${extractionError.message}`);
|
||||
}
|
||||
|
||||
// Clean up
|
||||
await plugins.fs.remove(outputPath);
|
||||
|
||||
} else {
|
||||
tools.log(` ⚠ ZUGFeRD ${zugferdTest.profile} file not created`);
|
||||
}
|
||||
|
||||
} else {
|
||||
tools.log(`⚠ ZUGFeRD ${zugferdTest.profile} creation returned no result`);
|
||||
}
|
||||
|
||||
} catch (creationError) {
|
||||
tools.log(`⚠ ZUGFeRD ${zugferdTest.profile} creation failed: ${creationError.message}`);
|
||||
}
|
||||
|
||||
} else {
|
||||
tools.log(`⚠ ZUGFeRD ${zugferdTest.profile} PDF/A-3 creation not supported`);
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
tools.log(`✗ ZUGFeRD ${zugferdTest.profile} test failed: ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
const duration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdfa3-creation-zugferd-profiles', duration);
|
||||
});
|
||||
|
||||
tap.test('PDF-05: PDF/A-3 Creation - Metadata and Accessibility', async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
// Test PDF/A-3 creation with comprehensive metadata and accessibility features
|
||||
const testXml = `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
|
||||
<ID>METADATA-ACCESSIBILITY-001</ID>
|
||||
<IssueDate>2024-01-01</IssueDate>
|
||||
<InvoiceTypeCode>380</InvoiceTypeCode>
|
||||
<DocumentCurrencyCode>EUR</DocumentCurrencyCode>
|
||||
<LegalMonetaryTotal>
|
||||
<PayableAmount currencyID="EUR">100.00</PayableAmount>
|
||||
</LegalMonetaryTotal>
|
||||
</Invoice>`;
|
||||
|
||||
const metadataTests = [
|
||||
{
|
||||
name: 'Comprehensive Metadata',
|
||||
options: {
|
||||
title: 'Electronic Invoice METADATA-ACCESSIBILITY-001',
|
||||
author: 'EInvoice Test Suite',
|
||||
subject: 'PDF/A-3 compliant invoice with comprehensive metadata',
|
||||
keywords: 'invoice, electronic, PDF/A-3, ZUGFeRD, accessible',
|
||||
creator: 'EInvoice PDF Generator',
|
||||
producer: 'EInvoice Test Framework',
|
||||
creationDate: new Date('2024-01-01'),
|
||||
modificationDate: new Date(),
|
||||
language: 'en-US'
|
||||
}
|
||||
},
|
||||
{
|
||||
name: 'Accessibility Features',
|
||||
options: {
|
||||
title: 'Accessible Electronic Invoice',
|
||||
tagged: true, // Structured PDF for screen readers
|
||||
displayDocTitle: true,
|
||||
linearized: true, // Fast web view
|
||||
complianceLevel: 'PDF/A-3A', // Accessibility compliance
|
||||
structuredPdf: true
|
||||
}
|
||||
},
|
||||
{
|
||||
name: 'Internationalization',
|
||||
options: {
|
||||
title: 'Elektronische Rechnung / Facture Électronique',
|
||||
language: 'de-DE',
|
||||
keywords: 'Rechnung, elektronisch, PDF/A-3, ZUGFeRD, Factur-X',
|
||||
unicodeSupport: true,
|
||||
characterEncoding: 'UTF-8'
|
||||
}
|
||||
}
|
||||
];
|
||||
|
||||
for (const metadataTest of metadataTests) {
|
||||
tools.log(`Testing ${metadataTest.name}...`);
|
||||
|
||||
try {
|
||||
const invoice = new EInvoice();
|
||||
await invoice.fromXmlString(testXml);
|
||||
|
||||
if (typeof invoice.createPdfA3 === '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 creationOptions = {
|
||||
outputPath: outputPath,
|
||||
xmlContent: testXml,
|
||||
attachmentName: 'invoice.xml',
|
||||
complianceLevel: 'PDF/A-3B',
|
||||
...metadataTest.options
|
||||
};
|
||||
|
||||
try {
|
||||
const creationResult = await invoice.createPdfA3(creationOptions);
|
||||
|
||||
if (creationResult) {
|
||||
tools.log(`✓ ${metadataTest.name} PDF/A-3 creation completed`);
|
||||
|
||||
const outputExists = await plugins.fs.pathExists(outputPath);
|
||||
if (outputExists) {
|
||||
const outputStats = await plugins.fs.stat(outputPath);
|
||||
tools.log(` File size: ${(outputStats.size / 1024).toFixed(1)}KB`);
|
||||
|
||||
// Basic metadata validation by reading PDF content
|
||||
const pdfContent = await plugins.fs.readFile(outputPath, { encoding: 'binary' });
|
||||
|
||||
// Check for metadata presence (simplified check)
|
||||
if (metadataTest.options.title && pdfContent.includes(metadataTest.options.title)) {
|
||||
tools.log(` ✓ Title metadata preserved`);
|
||||
}
|
||||
|
||||
if (metadataTest.options.author && pdfContent.includes(metadataTest.options.author)) {
|
||||
tools.log(` ✓ Author metadata preserved`);
|
||||
}
|
||||
|
||||
if (metadataTest.options.keywords && metadataTest.options.keywords.split(',').some(keyword =>
|
||||
pdfContent.includes(keyword.trim()))) {
|
||||
tools.log(` ✓ Keywords metadata preserved`);
|
||||
}
|
||||
|
||||
// Check for accessibility features
|
||||
if (metadataTest.options.tagged && (pdfContent.includes('/StructTreeRoot') || pdfContent.includes('/Marked'))) {
|
||||
tools.log(` ✓ PDF structure/tagging detected`);
|
||||
}
|
||||
|
||||
// Check for compliance level
|
||||
if (metadataTest.options.complianceLevel && pdfContent.includes(metadataTest.options.complianceLevel)) {
|
||||
tools.log(` ✓ Compliance level preserved`);
|
||||
}
|
||||
|
||||
// Clean up
|
||||
await plugins.fs.remove(outputPath);
|
||||
|
||||
} else {
|
||||
tools.log(` ⚠ ${metadataTest.name} file not created`);
|
||||
}
|
||||
|
||||
} else {
|
||||
tools.log(`⚠ ${metadataTest.name} creation returned no result`);
|
||||
}
|
||||
|
||||
} catch (creationError) {
|
||||
tools.log(`⚠ ${metadataTest.name} creation failed: ${creationError.message}`);
|
||||
}
|
||||
|
||||
} else {
|
||||
tools.log(`⚠ ${metadataTest.name} PDF/A-3 creation not supported`);
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
tools.log(`✗ ${metadataTest.name} test failed: ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
const duration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdfa3-creation-metadata-accessibility', duration);
|
||||
});
|
||||
|
||||
tap.test('PDF-05: PDF/A-3 Creation - Performance and Size Optimization', async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
// Test PDF/A-3 creation performance with different optimization settings
|
||||
const optimizationTests = [
|
||||
{
|
||||
name: 'Standard Quality',
|
||||
options: {
|
||||
imageQuality: 'standard',
|
||||
compression: 'standard',
|
||||
optimizeFor: 'balanced'
|
||||
}
|
||||
},
|
||||
{
|
||||
name: 'High Quality',
|
||||
options: {
|
||||
imageQuality: 'high',
|
||||
compression: 'minimal',
|
||||
optimizeFor: 'quality'
|
||||
}
|
||||
},
|
||||
{
|
||||
name: 'Small Size',
|
||||
options: {
|
||||
imageQuality: 'medium',
|
||||
compression: 'maximum',
|
||||
optimizeFor: 'size'
|
||||
}
|
||||
},
|
||||
{
|
||||
name: 'Fast Generation',
|
||||
options: {
|
||||
imageQuality: 'medium',
|
||||
compression: 'fast',
|
||||
optimizeFor: 'speed'
|
||||
}
|
||||
}
|
||||
];
|
||||
|
||||
const testXml = `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
|
||||
<ID>PERFORMANCE-TEST-001</ID>
|
||||
<IssueDate>2024-01-01</IssueDate>
|
||||
<InvoiceTypeCode>380</InvoiceTypeCode>
|
||||
<DocumentCurrencyCode>EUR</DocumentCurrencyCode>
|
||||
<LegalMonetaryTotal>
|
||||
<PayableAmount currencyID="EUR">100.00</PayableAmount>
|
||||
</LegalMonetaryTotal>
|
||||
</Invoice>`;
|
||||
|
||||
const performanceResults = [];
|
||||
|
||||
for (const optimizationTest of optimizationTests) {
|
||||
tools.log(`Testing ${optimizationTest.name} optimization...`);
|
||||
|
||||
try {
|
||||
const invoice = new EInvoice();
|
||||
await invoice.fromXmlString(testXml);
|
||||
|
||||
if (typeof invoice.createPdfA3 === 'function') {
|
||||
const outputPath = plugins.path.join(process.cwd(), '.nogit', `test-${optimizationTest.name.toLowerCase().replace(/\s+/g, '-')}.pdf`);
|
||||
await plugins.fs.ensureDir(plugins.path.dirname(outputPath));
|
||||
|
||||
const creationStartTime = Date.now();
|
||||
|
||||
const creationOptions = {
|
||||
outputPath: outputPath,
|
||||
xmlContent: testXml,
|
||||
attachmentName: 'invoice.xml',
|
||||
complianceLevel: 'PDF/A-3B',
|
||||
title: `Performance Test - ${optimizationTest.name}`,
|
||||
...optimizationTest.options
|
||||
};
|
||||
|
||||
try {
|
||||
const creationResult = await invoice.createPdfA3(creationOptions);
|
||||
const creationTime = Date.now() - creationStartTime;
|
||||
|
||||
if (creationResult) {
|
||||
const outputExists = await plugins.fs.pathExists(outputPath);
|
||||
if (outputExists) {
|
||||
const outputStats = await plugins.fs.stat(outputPath);
|
||||
const fileSizeKB = outputStats.size / 1024;
|
||||
|
||||
const result = {
|
||||
name: optimizationTest.name,
|
||||
creationTimeMs: creationTime,
|
||||
fileSizeKB: fileSizeKB,
|
||||
...optimizationTest.options
|
||||
};
|
||||
|
||||
performanceResults.push(result);
|
||||
|
||||
tools.log(` Creation time: ${creationTime}ms`);
|
||||
tools.log(` File size: ${fileSizeKB.toFixed(1)}KB`);
|
||||
tools.log(` Performance ratio: ${(creationTime / fileSizeKB).toFixed(2)}ms/KB`);
|
||||
|
||||
// Clean up
|
||||
await plugins.fs.remove(outputPath);
|
||||
|
||||
} else {
|
||||
tools.log(` ⚠ ${optimizationTest.name} file not created`);
|
||||
}
|
||||
|
||||
} else {
|
||||
tools.log(`⚠ ${optimizationTest.name} creation returned no result`);
|
||||
}
|
||||
|
||||
} catch (creationError) {
|
||||
tools.log(`⚠ ${optimizationTest.name} creation failed: ${creationError.message}`);
|
||||
}
|
||||
|
||||
} else {
|
||||
tools.log(`⚠ ${optimizationTest.name} PDF/A-3 creation not supported`);
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
tools.log(`✗ ${optimizationTest.name} test failed: ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
// Analyze performance results
|
||||
if (performanceResults.length > 0) {
|
||||
tools.log(`\nPDF/A-3 Performance Analysis:`);
|
||||
|
||||
const fastestCreation = performanceResults.reduce((min, r) => r.creationTimeMs < min.creationTimeMs ? r : min);
|
||||
const smallestFile = performanceResults.reduce((min, r) => r.fileSizeKB < min.fileSizeKB ? r : min);
|
||||
const avgCreationTime = performanceResults.reduce((sum, r) => sum + r.creationTimeMs, 0) / performanceResults.length;
|
||||
const avgFileSize = performanceResults.reduce((sum, r) => sum + r.fileSizeKB, 0) / performanceResults.length;
|
||||
|
||||
tools.log(`- Fastest creation: ${fastestCreation.name} (${fastestCreation.creationTimeMs}ms)`);
|
||||
tools.log(`- Smallest file: ${smallestFile.name} (${smallestFile.fileSizeKB.toFixed(1)}KB)`);
|
||||
tools.log(`- Average creation time: ${avgCreationTime.toFixed(1)}ms`);
|
||||
tools.log(`- Average file size: ${avgFileSize.toFixed(1)}KB`);
|
||||
|
||||
// Performance expectations
|
||||
expect(avgCreationTime).toBeLessThan(5000); // 5 seconds max average
|
||||
expect(avgFileSize).toBeLessThan(500); // 500KB max average
|
||||
}
|
||||
|
||||
const duration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdfa3-creation-performance-optimization', duration);
|
||||
});
|
||||
|
||||
tap.test('PDF-05: Performance Summary', async (tools) => {
|
||||
const operations = [
|
||||
'pdfa3-creation-basic',
|
||||
'pdfa3-creation-compliance-levels',
|
||||
'pdfa3-creation-zugferd-profiles',
|
||||
'pdfa3-creation-metadata-accessibility',
|
||||
'pdfa3-creation-performance-optimization'
|
||||
];
|
||||
|
||||
tools.log(`\n=== PDF/A-3 Creation 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`);
|
||||
}
|
||||
}
|
||||
|
||||
tools.log(`\nPDF/A-3 creation testing completed.`);
|
||||
});
|
||||
@ -0,0 +1,412 @@
|
||||
import { expect, tap } from '@git.zone/tstest/tapbundle';
|
||||
import * as plugins from '../plugins.js';
|
||||
import { EInvoice } from '../../../ts/index.js';
|
||||
import { CorpusLoader } from '../corpus.loader.js';
|
||||
import { PerformanceTracker } from '../performance.tracker.js';
|
||||
|
||||
tap.test('PDF-06: Multiple Attachments - should handle PDFs with multiple embedded files', async (t) => {
|
||||
// PDF-06: Verify handling of PDFs containing multiple attachments
|
||||
// This test ensures proper extraction and management of multiple embedded files
|
||||
|
||||
const performanceTracker = new PerformanceTracker('PDF-06: Multiple Attachments');
|
||||
const corpusLoader = new CorpusLoader();
|
||||
|
||||
t.test('Detect multiple attachments in PDF', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
// Create a test PDF with multiple attachments
|
||||
const { PDFDocument, PDFName, AFRelationship } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
// Add first page
|
||||
const page = pdfDoc.addPage([595, 842]); // A4
|
||||
page.drawText('Invoice with Multiple Attachments', {
|
||||
x: 50,
|
||||
y: 750,
|
||||
size: 20
|
||||
});
|
||||
|
||||
// Add multiple XML attachments
|
||||
const attachments = [
|
||||
{
|
||||
name: 'invoice.xml',
|
||||
content: `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
|
||||
<ID>MULTI-ATTACH-001</ID>
|
||||
<IssueDate>2025-01-25</IssueDate>
|
||||
<Note>Main invoice document</Note>
|
||||
</Invoice>`,
|
||||
relationship: AFRelationship.Data,
|
||||
description: 'Main invoice XML'
|
||||
},
|
||||
{
|
||||
name: 'supplementary.xml',
|
||||
content: `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<SupplementaryData>
|
||||
<InvoiceRef>MULTI-ATTACH-001</InvoiceRef>
|
||||
<AdditionalInfo>Extra invoice details</AdditionalInfo>
|
||||
</SupplementaryData>`,
|
||||
relationship: AFRelationship.Supplement,
|
||||
description: 'Supplementary invoice data'
|
||||
},
|
||||
{
|
||||
name: 'signature.xml',
|
||||
content: `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Signature xmlns="http://www.w3.org/2000/09/xmldsig#">
|
||||
<SignedInfo>
|
||||
<Reference URI="#invoice">
|
||||
<DigestValue>abc123...</DigestValue>
|
||||
</Reference>
|
||||
</SignedInfo>
|
||||
</Signature>`,
|
||||
relationship: AFRelationship.Source,
|
||||
description: 'Digital signature'
|
||||
}
|
||||
];
|
||||
|
||||
// Embed each attachment
|
||||
for (const attachment of attachments) {
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(attachment.content, 'utf8'),
|
||||
attachment.name,
|
||||
{
|
||||
mimeType: 'application/xml',
|
||||
description: attachment.description,
|
||||
creationDate: new Date(),
|
||||
modificationDate: new Date(),
|
||||
afRelationship: attachment.relationship
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
// Add metadata
|
||||
pdfDoc.setTitle('Multi-attachment Invoice');
|
||||
pdfDoc.setSubject('Invoice with multiple embedded files');
|
||||
pdfDoc.setKeywords(['invoice', 'multiple-attachments', 'xml']);
|
||||
|
||||
// Save PDF
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
|
||||
// Test extraction
|
||||
const einvoice = new EInvoice();
|
||||
try {
|
||||
await einvoice.loadFromPdfBuffer(pdfBytes);
|
||||
|
||||
// Check if multiple attachments are detected
|
||||
// Note: The API might not expose all attachments directly
|
||||
const xmlContent = einvoice.getXmlString();
|
||||
expect(xmlContent).toContain('MULTI-ATTACH-001');
|
||||
|
||||
console.log('Successfully extracted primary attachment from multi-attachment PDF');
|
||||
} catch (error) {
|
||||
console.log('Multi-attachment extraction not fully supported:', error.message);
|
||||
}
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('detect-multiple', elapsed);
|
||||
});
|
||||
|
||||
t.test('Extract all attachments from PDF', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
// Create PDF with various attachment types
|
||||
const { PDFDocument } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
const page = pdfDoc.addPage();
|
||||
|
||||
// Different file types as attachments
|
||||
const mixedAttachments = [
|
||||
{
|
||||
name: 'invoice_data.xml',
|
||||
content: '<?xml version="1.0"?><invoice><id>TEST-001</id></invoice>',
|
||||
mimeType: 'application/xml'
|
||||
},
|
||||
{
|
||||
name: 'invoice_image.txt',
|
||||
content: 'BASE64_ENCODED_IMAGE_DATA_HERE',
|
||||
mimeType: 'text/plain'
|
||||
},
|
||||
{
|
||||
name: 'invoice_style.css',
|
||||
content: '.invoice { font-family: Arial; }',
|
||||
mimeType: 'text/css'
|
||||
},
|
||||
{
|
||||
name: 'invoice_meta.json',
|
||||
content: '{"version":"1.0","format":"UBL"}',
|
||||
mimeType: 'application/json'
|
||||
}
|
||||
];
|
||||
|
||||
for (const attach of mixedAttachments) {
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(attach.content, 'utf8'),
|
||||
attach.name,
|
||||
{
|
||||
mimeType: attach.mimeType,
|
||||
description: `${attach.name} attachment`
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
|
||||
// Test if we can identify all attachments
|
||||
const einvoice = new EInvoice();
|
||||
try {
|
||||
await einvoice.loadFromPdfBuffer(pdfBytes);
|
||||
|
||||
// The library might only extract XML attachments
|
||||
console.log('Extracted attachment from PDF with mixed file types');
|
||||
} catch (error) {
|
||||
console.log('Mixed attachment handling:', error.message);
|
||||
}
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('extract-all', elapsed);
|
||||
});
|
||||
|
||||
t.test('Handle attachment relationships', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument, AFRelationship } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
const page = pdfDoc.addPage();
|
||||
|
||||
// Test different AFRelationship types
|
||||
const relationshipTests = [
|
||||
{ rel: AFRelationship.Source, desc: 'Source document' },
|
||||
{ rel: AFRelationship.Data, desc: 'Data file' },
|
||||
{ rel: AFRelationship.Alternative, desc: 'Alternative representation' },
|
||||
{ rel: AFRelationship.Supplement, desc: 'Supplementary data' },
|
||||
{ rel: AFRelationship.Unspecified, desc: 'Unspecified relationship' }
|
||||
];
|
||||
|
||||
for (const test of relationshipTests) {
|
||||
const xmlContent = `<?xml version="1.0"?>
|
||||
<Document type="${test.desc}">
|
||||
<Relationship>${test.rel}</Relationship>
|
||||
</Document>`;
|
||||
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(xmlContent, 'utf8'),
|
||||
`${test.rel}_document.xml`,
|
||||
{
|
||||
mimeType: 'application/xml',
|
||||
description: test.desc,
|
||||
afRelationship: test.rel
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
expect(pdfBytes.length).toBeGreaterThan(0);
|
||||
|
||||
console.log('Created PDF with various attachment relationships');
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('relationships', elapsed);
|
||||
});
|
||||
|
||||
t.test('Attachment size limits', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
const page = pdfDoc.addPage();
|
||||
|
||||
// Test with increasingly large attachments
|
||||
const sizes = [
|
||||
{ size: 1024, name: '1KB' }, // 1 KB
|
||||
{ size: 10 * 1024, name: '10KB' }, // 10 KB
|
||||
{ size: 100 * 1024, name: '100KB' }, // 100 KB
|
||||
{ size: 1024 * 1024, name: '1MB' } // 1 MB
|
||||
];
|
||||
|
||||
for (const sizeTest of sizes) {
|
||||
// Generate XML content of specified size
|
||||
let content = '<?xml version="1.0" encoding="UTF-8"?>\n<LargeInvoice>\n';
|
||||
const padding = '<Data>';
|
||||
while (content.length < sizeTest.size - 100) {
|
||||
content += padding + 'x'.repeat(80) + '</Data>\n';
|
||||
}
|
||||
content += '</LargeInvoice>';
|
||||
|
||||
try {
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(content, 'utf8'),
|
||||
`large_${sizeTest.name}.xml`,
|
||||
{
|
||||
mimeType: 'application/xml',
|
||||
description: `Large attachment test ${sizeTest.name}`
|
||||
}
|
||||
);
|
||||
console.log(`Successfully attached ${sizeTest.name} file`);
|
||||
} catch (error) {
|
||||
console.log(`Failed to attach ${sizeTest.name}:`, error.message);
|
||||
}
|
||||
}
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
console.log(`Final PDF size with attachments: ${(pdfBytes.length / 1024).toFixed(2)} KB`);
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('size-limits', elapsed);
|
||||
});
|
||||
|
||||
t.test('Duplicate attachment names', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
const page = pdfDoc.addPage();
|
||||
|
||||
// Try to add multiple attachments with same name
|
||||
const attachmentName = 'invoice.xml';
|
||||
const versions = [
|
||||
{ content: '<invoice version="1.0"/>', desc: 'Version 1.0' },
|
||||
{ content: '<invoice version="2.0"/>', desc: 'Version 2.0' },
|
||||
{ content: '<invoice version="3.0"/>', desc: 'Version 3.0' }
|
||||
];
|
||||
|
||||
for (const version of versions) {
|
||||
try {
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(version.content, 'utf8'),
|
||||
attachmentName,
|
||||
{
|
||||
mimeType: 'application/xml',
|
||||
description: version.desc
|
||||
}
|
||||
);
|
||||
console.log(`Attached: ${version.desc}`);
|
||||
} catch (error) {
|
||||
console.log(`Duplicate name handling for ${version.desc}:`, error.message);
|
||||
}
|
||||
}
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
|
||||
// Check if duplicates are handled
|
||||
const einvoice = new EInvoice();
|
||||
try {
|
||||
await einvoice.loadFromPdfBuffer(pdfBytes);
|
||||
console.log('Handled PDF with duplicate attachment names');
|
||||
} catch (error) {
|
||||
console.log('Duplicate name error:', error.message);
|
||||
}
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('duplicate-names', elapsed);
|
||||
});
|
||||
|
||||
t.test('Corpus PDFs with multiple attachments', async () => {
|
||||
const startTime = performance.now();
|
||||
let multiAttachmentCount = 0;
|
||||
let processedCount = 0;
|
||||
|
||||
const files = await corpusLoader.getAllFiles();
|
||||
const pdfFiles = files.filter(f => f.endsWith('.pdf'));
|
||||
|
||||
// Sample PDFs to check for multiple attachments
|
||||
const sampleSize = Math.min(30, pdfFiles.length);
|
||||
const sample = pdfFiles.slice(0, sampleSize);
|
||||
|
||||
for (const file of sample) {
|
||||
try {
|
||||
const content = await corpusLoader.readFile(file);
|
||||
const einvoice = new EInvoice();
|
||||
|
||||
// Try to load and check for attachments
|
||||
try {
|
||||
await einvoice.loadFromPdfBuffer(content);
|
||||
|
||||
// Check if PDF might have multiple attachments
|
||||
// This is approximate since we can't directly query attachment count
|
||||
const pdfString = content.toString('binary');
|
||||
const attachmentMatches = pdfString.match(/\/EmbeddedFiles/g);
|
||||
|
||||
if (attachmentMatches && attachmentMatches.length > 1) {
|
||||
multiAttachmentCount++;
|
||||
console.log(`Multiple attachments detected in: ${file}`);
|
||||
}
|
||||
} catch (error) {
|
||||
// Skip PDFs that can't be processed
|
||||
}
|
||||
|
||||
processedCount++;
|
||||
} catch (error) {
|
||||
console.log(`Error reading ${file}:`, error.message);
|
||||
}
|
||||
}
|
||||
|
||||
console.log(`Corpus analysis: ${multiAttachmentCount}/${processedCount} PDFs may have multiple attachments`);
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('corpus-multi-attach', elapsed);
|
||||
});
|
||||
|
||||
t.test('Attachment extraction order', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument, AFRelationship } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
const page = pdfDoc.addPage();
|
||||
|
||||
// Add attachments in specific order
|
||||
const orderedAttachments = [
|
||||
{ name: '1_first.xml', priority: 'high', afRel: AFRelationship.Data },
|
||||
{ name: '2_second.xml', priority: 'medium', afRel: AFRelationship.Supplement },
|
||||
{ name: '3_third.xml', priority: 'low', afRel: AFRelationship.Alternative }
|
||||
];
|
||||
|
||||
for (const attach of orderedAttachments) {
|
||||
const content = `<?xml version="1.0"?>
|
||||
<Document>
|
||||
<Order>${attach.name}</Order>
|
||||
<Priority>${attach.priority}</Priority>
|
||||
</Document>`;
|
||||
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(content, 'utf8'),
|
||||
attach.name,
|
||||
{
|
||||
mimeType: 'application/xml',
|
||||
description: `Priority: ${attach.priority}`,
|
||||
afRelationship: attach.afRel
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
|
||||
// Test extraction order
|
||||
const einvoice = new EInvoice();
|
||||
try {
|
||||
await einvoice.loadFromPdfBuffer(pdfBytes);
|
||||
|
||||
// Check which attachment was extracted
|
||||
const xmlContent = einvoice.getXmlString();
|
||||
console.log('Extraction order test completed');
|
||||
|
||||
// Library likely extracts based on AFRelationship priority
|
||||
if (xmlContent.includes('1_first.xml')) {
|
||||
console.log('Extracted primary (Data) attachment first');
|
||||
}
|
||||
} catch (error) {
|
||||
console.log('Order extraction error:', error.message);
|
||||
}
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('extraction-order', elapsed);
|
||||
});
|
||||
|
||||
// Print performance summary
|
||||
performanceTracker.printSummary();
|
||||
|
||||
// Performance assertions
|
||||
const avgTime = performanceTracker.getAverageTime();
|
||||
expect(avgTime).toBeLessThan(500); // Multiple attachments may take longer
|
||||
});
|
||||
|
||||
tap.start();
|
||||
@ -0,0 +1,412 @@
|
||||
import { expect, tap } from '@git.zone/tstest/tapbundle';
|
||||
import * as plugins from '../plugins.js';
|
||||
import { EInvoice } from '../../../ts/index.js';
|
||||
import { CorpusLoader } from '../corpus.loader.js';
|
||||
import { PerformanceTracker } from '../performance.tracker.js';
|
||||
|
||||
tap.test('PDF-07: Metadata Preservation - should preserve PDF metadata during operations', async (t) => {
|
||||
// PDF-07: Verify PDF metadata is preserved when embedding/extracting XML
|
||||
// This test ensures document properties and metadata remain intact
|
||||
|
||||
const performanceTracker = new PerformanceTracker('PDF-07: Metadata Preservation');
|
||||
const corpusLoader = new CorpusLoader();
|
||||
|
||||
t.test('Preserve standard PDF metadata', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
// Set comprehensive metadata
|
||||
const metadata = {
|
||||
title: 'Test Invoice 2025-001',
|
||||
author: 'Invoice System v3.0',
|
||||
subject: 'Monthly Invoice for Services',
|
||||
keywords: ['invoice', 'zugferd', 'factur-x', 'electronic', 'billing'],
|
||||
creator: 'EInvoice Library',
|
||||
producer: 'PDFLib Test Suite',
|
||||
creationDate: new Date('2025-01-01T10:00:00Z'),
|
||||
modificationDate: new Date('2025-01-25T14:30:00Z')
|
||||
};
|
||||
|
||||
pdfDoc.setTitle(metadata.title);
|
||||
pdfDoc.setAuthor(metadata.author);
|
||||
pdfDoc.setSubject(metadata.subject);
|
||||
pdfDoc.setKeywords(metadata.keywords);
|
||||
pdfDoc.setCreator(metadata.creator);
|
||||
pdfDoc.setProducer(metadata.producer);
|
||||
pdfDoc.setCreationDate(metadata.creationDate);
|
||||
pdfDoc.setModificationDate(metadata.modificationDate);
|
||||
|
||||
// Add content
|
||||
const page = pdfDoc.addPage([595, 842]);
|
||||
page.drawText('Invoice with Metadata', { x: 50, y: 750, size: 20 });
|
||||
|
||||
// Add invoice XML
|
||||
const xmlContent = `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
|
||||
<ID>METADATA-TEST-001</ID>
|
||||
<IssueDate>2025-01-25</IssueDate>
|
||||
<DocumentCurrencyCode>EUR</DocumentCurrencyCode>
|
||||
</Invoice>`;
|
||||
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(xmlContent, 'utf8'),
|
||||
'invoice.xml',
|
||||
{
|
||||
mimeType: 'application/xml',
|
||||
description: 'Invoice XML data',
|
||||
afRelationship: plugins.AFRelationship.Data
|
||||
}
|
||||
);
|
||||
|
||||
const originalPdfBytes = await pdfDoc.save();
|
||||
|
||||
// Load into EInvoice and process
|
||||
const einvoice = new EInvoice();
|
||||
await einvoice.loadFromPdfBuffer(originalPdfBytes);
|
||||
|
||||
// Get back as PDF (if supported)
|
||||
try {
|
||||
const processedPdf = await einvoice.getPdfBuffer();
|
||||
|
||||
// Load processed PDF and check metadata
|
||||
const processedDoc = await PDFDocument.load(processedPdf);
|
||||
|
||||
expect(processedDoc.getTitle()).toBe(metadata.title);
|
||||
expect(processedDoc.getAuthor()).toBe(metadata.author);
|
||||
expect(processedDoc.getSubject()).toBe(metadata.subject);
|
||||
expect(processedDoc.getKeywords()).toBe(metadata.keywords.join(', '));
|
||||
expect(processedDoc.getCreator()).toBe(metadata.creator);
|
||||
|
||||
console.log('All metadata preserved successfully');
|
||||
} catch (error) {
|
||||
console.log('PDF metadata preservation not fully supported:', error.message);
|
||||
}
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('standard-metadata', elapsed);
|
||||
});
|
||||
|
||||
t.test('Preserve custom metadata properties', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument, PDFDict, PDFName, PDFString } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
// Add standard content
|
||||
const page = pdfDoc.addPage();
|
||||
page.drawText('Custom Metadata Test', { x: 50, y: 700, size: 16 });
|
||||
|
||||
// Access the info dictionary for custom properties
|
||||
const infoDict = pdfDoc.context.trailerInfo.Info;
|
||||
if (infoDict instanceof PDFDict) {
|
||||
// Add custom metadata fields
|
||||
infoDict.set(PDFName.of('InvoiceNumber'), PDFString.of('INV-2025-001'));
|
||||
infoDict.set(PDFName.of('InvoiceDate'), PDFString.of('2025-01-25'));
|
||||
infoDict.set(PDFName.of('CustomerID'), PDFString.of('CUST-12345'));
|
||||
infoDict.set(PDFName.of('InvoiceType'), PDFString.of('ZUGFeRD 2.1'));
|
||||
infoDict.set(PDFName.of('PaymentTerms'), PDFString.of('Net 30 days'));
|
||||
infoDict.set(PDFName.of('TaxRate'), PDFString.of('19%'));
|
||||
}
|
||||
|
||||
// Add XML attachment
|
||||
const xmlContent = `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Invoice>
|
||||
<ID>INV-2025-001</ID>
|
||||
<CustomerID>CUST-12345</CustomerID>
|
||||
</Invoice>`;
|
||||
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(xmlContent, 'utf8'),
|
||||
'invoice.xml',
|
||||
{
|
||||
mimeType: 'application/xml',
|
||||
description: 'Invoice data with custom metadata'
|
||||
}
|
||||
);
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
|
||||
// Check if custom metadata is readable
|
||||
const loadedDoc = await PDFDocument.load(pdfBytes);
|
||||
const loadedInfo = loadedDoc.context.trailerInfo.Info;
|
||||
|
||||
if (loadedInfo instanceof PDFDict) {
|
||||
const invoiceNum = loadedInfo.get(PDFName.of('InvoiceNumber'));
|
||||
console.log('Custom metadata preserved in PDF');
|
||||
}
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('custom-metadata', elapsed);
|
||||
});
|
||||
|
||||
t.test('XMP metadata preservation', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
|
||||
// Create XMP metadata
|
||||
const xmpMetadata = `<?xpacket begin="" id="W5M0MpCehiHzreSzNTczkc9d"?>
|
||||
<x:xmpmeta xmlns:x="adobe:ns:meta/">
|
||||
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
|
||||
<rdf:Description rdf:about=""
|
||||
xmlns:dc="http://purl.org/dc/elements/1.1/"
|
||||
xmlns:pdf="http://ns.adobe.com/pdf/1.3/"
|
||||
xmlns:xmp="http://ns.adobe.com/xap/1.0/"
|
||||
xmlns:fx="urn:factur-x:pdfa:CrossIndustryDocument:invoice:1p0#">
|
||||
<dc:title>
|
||||
<rdf:Alt>
|
||||
<rdf:li xml:lang="x-default">Electronic Invoice</rdf:li>
|
||||
</rdf:Alt>
|
||||
</dc:title>
|
||||
<dc:creator>
|
||||
<rdf:Seq>
|
||||
<rdf:li>EInvoice System</rdf:li>
|
||||
</rdf:Seq>
|
||||
</dc:creator>
|
||||
<dc:description>
|
||||
<rdf:Alt>
|
||||
<rdf:li xml:lang="x-default">ZUGFeRD 2.1 compliant invoice</rdf:li>
|
||||
</rdf:Alt>
|
||||
</dc:description>
|
||||
<pdf:Producer>EInvoice Library with PDFLib</pdf:Producer>
|
||||
<xmp:CreateDate>2025-01-25T10:00:00Z</xmp:CreateDate>
|
||||
<xmp:ModifyDate>2025-01-25T14:30:00Z</xmp:ModifyDate>
|
||||
<fx:DocumentType>INVOICE</fx:DocumentType>
|
||||
<fx:DocumentFileName>invoice.xml</fx:DocumentFileName>
|
||||
<fx:Version>2.1</fx:Version>
|
||||
<fx:ConformanceLevel>EXTENDED</fx:ConformanceLevel>
|
||||
</rdf:Description>
|
||||
</rdf:RDF>
|
||||
</x:xmpmeta>
|
||||
<?xpacket end="w"?>`;
|
||||
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
// Note: pdf-lib doesn't directly support XMP metadata
|
||||
// This would require a more advanced PDF library
|
||||
console.log('XMP metadata test - requires advanced PDF library support');
|
||||
|
||||
// Add basic content
|
||||
const page = pdfDoc.addPage();
|
||||
page.drawText('XMP Metadata Test', { x: 50, y: 700, size: 16 });
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('xmp-metadata', elapsed);
|
||||
});
|
||||
|
||||
t.test('Metadata during format conversion', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
// Test metadata preservation during invoice format conversion
|
||||
const xmlContent = `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
|
||||
<UBLVersionID>2.1</UBLVersionID>
|
||||
<ID>META-CONV-001</ID>
|
||||
<IssueDate>2025-01-25</IssueDate>
|
||||
<Note>Invoice with metadata for conversion test</Note>
|
||||
<DocumentCurrencyCode>EUR</DocumentCurrencyCode>
|
||||
<AccountingSupplierParty>
|
||||
<Party>
|
||||
<PartyName>
|
||||
<Name>Test Supplier GmbH</Name>
|
||||
</PartyName>
|
||||
</Party>
|
||||
</AccountingSupplierParty>
|
||||
</Invoice>`;
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
// Set metadata that should be preserved
|
||||
pdfDoc.setTitle('Conversion Test Invoice');
|
||||
pdfDoc.setAuthor('Metadata Test Suite');
|
||||
pdfDoc.setSubject('Testing metadata preservation during conversion');
|
||||
pdfDoc.setKeywords(['conversion', 'metadata', 'test']);
|
||||
pdfDoc.setCreationDate(new Date('2025-01-20T09:00:00Z'));
|
||||
|
||||
const page = pdfDoc.addPage();
|
||||
page.drawText('Metadata Conversion Test', { x: 50, y: 700, size: 16 });
|
||||
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(xmlContent, 'utf8'),
|
||||
'invoice.xml',
|
||||
{
|
||||
mimeType: 'application/xml',
|
||||
description: 'Invoice for metadata conversion test'
|
||||
}
|
||||
);
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
|
||||
// Test preservation through EInvoice processing
|
||||
const einvoice = new EInvoice();
|
||||
await einvoice.loadFromPdfBuffer(pdfBytes);
|
||||
|
||||
// Check if we can still access the metadata
|
||||
console.log('Metadata conversion test completed');
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('conversion-metadata', elapsed);
|
||||
});
|
||||
|
||||
t.test('Language and locale metadata', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
// Set language-specific metadata
|
||||
pdfDoc.setTitle('Rechnung Nr. 2025-001');
|
||||
pdfDoc.setAuthor('Rechnungssystem v3.0');
|
||||
pdfDoc.setSubject('Monatliche Rechnung für Dienstleistungen');
|
||||
pdfDoc.setKeywords(['Rechnung', 'ZUGFeRD', 'elektronisch', 'Deutschland']);
|
||||
pdfDoc.setLanguage('de-DE'); // German language tag
|
||||
|
||||
const page = pdfDoc.addPage();
|
||||
page.drawText('Deutsche Rechnung', { x: 50, y: 700, size: 20 });
|
||||
|
||||
// Add German invoice XML
|
||||
const xmlContent = `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<rsm:CrossIndustryInvoice xmlns:rsm="urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100">
|
||||
<rsm:ExchangedDocument>
|
||||
<ram:ID xmlns:ram="urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100">RECHNUNG-2025-001</ram:ID>
|
||||
<ram:Name xmlns:ram="urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100">Rechnung</ram:Name>
|
||||
<ram:LanguageID xmlns:ram="urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100">de</ram:LanguageID>
|
||||
</rsm:ExchangedDocument>
|
||||
</rsm:CrossIndustryInvoice>`;
|
||||
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(xmlContent, 'utf8'),
|
||||
'rechnung.xml',
|
||||
{
|
||||
mimeType: 'application/xml',
|
||||
description: 'Deutsche Rechnungsdaten'
|
||||
}
|
||||
);
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
expect(pdfBytes.length).toBeGreaterThan(0);
|
||||
|
||||
console.log('Language metadata test completed');
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('language-metadata', elapsed);
|
||||
});
|
||||
|
||||
t.test('Corpus metadata analysis', async () => {
|
||||
const startTime = performance.now();
|
||||
let metadataCount = 0;
|
||||
let processedCount = 0;
|
||||
const metadataTypes = {
|
||||
title: 0,
|
||||
author: 0,
|
||||
subject: 0,
|
||||
keywords: 0,
|
||||
creator: 0,
|
||||
producer: 0
|
||||
};
|
||||
|
||||
const files = await corpusLoader.getAllFiles();
|
||||
const pdfFiles = files.filter(f => f.endsWith('.pdf'));
|
||||
|
||||
// Sample PDFs for metadata analysis
|
||||
const sampleSize = Math.min(40, pdfFiles.length);
|
||||
const sample = pdfFiles.slice(0, sampleSize);
|
||||
|
||||
for (const file of sample) {
|
||||
try {
|
||||
const content = await corpusLoader.readFile(file);
|
||||
const { PDFDocument } = plugins;
|
||||
|
||||
try {
|
||||
const pdfDoc = await PDFDocument.load(content);
|
||||
|
||||
// Check for metadata
|
||||
const title = pdfDoc.getTitle();
|
||||
const author = pdfDoc.getAuthor();
|
||||
const subject = pdfDoc.getSubject();
|
||||
const keywords = pdfDoc.getKeywords();
|
||||
const creator = pdfDoc.getCreator();
|
||||
const producer = pdfDoc.getProducer();
|
||||
|
||||
if (title || author || subject || keywords || creator || producer) {
|
||||
metadataCount++;
|
||||
|
||||
if (title) metadataTypes.title++;
|
||||
if (author) metadataTypes.author++;
|
||||
if (subject) metadataTypes.subject++;
|
||||
if (keywords) metadataTypes.keywords++;
|
||||
if (creator) metadataTypes.creator++;
|
||||
if (producer) metadataTypes.producer++;
|
||||
}
|
||||
|
||||
processedCount++;
|
||||
} catch (error) {
|
||||
// Skip PDFs that can't be loaded
|
||||
}
|
||||
} catch (error) {
|
||||
console.log(`Error reading ${file}:`, error.message);
|
||||
}
|
||||
}
|
||||
|
||||
console.log(`Corpus metadata analysis (${processedCount} PDFs):`);
|
||||
console.log(`- PDFs with metadata: ${metadataCount}`);
|
||||
console.log('Metadata field frequency:', metadataTypes);
|
||||
|
||||
expect(processedCount).toBeGreaterThan(0);
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('corpus-metadata', elapsed);
|
||||
});
|
||||
|
||||
t.test('Metadata size and encoding', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
// Test with very long metadata values
|
||||
const longTitle = 'Invoice ' + 'Document '.repeat(50) + 'Title';
|
||||
const longKeywords = Array(100).fill('keyword').map((k, i) => `${k}${i}`);
|
||||
const longSubject = 'This is a very detailed subject line that describes the invoice document in great detail. '.repeat(5);
|
||||
|
||||
pdfDoc.setTitle(longTitle.substring(0, 255)); // PDF might have limits
|
||||
pdfDoc.setKeywords(longKeywords.slice(0, 50)); // Reasonable limit
|
||||
pdfDoc.setSubject(longSubject.substring(0, 500));
|
||||
|
||||
// Test special characters in metadata
|
||||
pdfDoc.setAuthor('Müller & Associés S.à r.l.');
|
||||
pdfDoc.setCreator('System © 2025 • München');
|
||||
|
||||
const page = pdfDoc.addPage();
|
||||
page.drawText('Metadata Size Test', { x: 50, y: 700, size: 16 });
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
|
||||
// Verify metadata was set
|
||||
const loadedDoc = await PDFDocument.load(pdfBytes);
|
||||
const loadedTitle = loadedDoc.getTitle();
|
||||
const loadedAuthor = loadedDoc.getAuthor();
|
||||
|
||||
expect(loadedTitle).toBeTruthy();
|
||||
expect(loadedAuthor).toContain('Müller');
|
||||
|
||||
console.log('Metadata size and encoding test completed');
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('metadata-size', elapsed);
|
||||
});
|
||||
|
||||
// Print performance summary
|
||||
performanceTracker.printSummary();
|
||||
|
||||
// Performance assertions
|
||||
const avgTime = performanceTracker.getAverageTime();
|
||||
expect(avgTime).toBeLessThan(300); // Metadata operations should be fast
|
||||
});
|
||||
|
||||
tap.start();
|
||||
@ -0,0 +1,495 @@
|
||||
import { expect, tap } from '@git.zone/tstest/tapbundle';
|
||||
import * as plugins from '../plugins.js';
|
||||
import { EInvoice } from '../../../ts/index.js';
|
||||
import { CorpusLoader } from '../corpus.loader.js';
|
||||
import { PerformanceTracker } from '../performance.tracker.js';
|
||||
|
||||
tap.test('PDF-08: Large PDF Performance - should handle large PDFs efficiently', async (t) => {
|
||||
// PDF-08: Verify performance with large PDF files
|
||||
// This test ensures the system can handle large PDFs without memory issues
|
||||
|
||||
const performanceTracker = new PerformanceTracker('PDF-08: Large PDF Performance');
|
||||
const corpusLoader = new CorpusLoader();
|
||||
|
||||
t.test('Process PDFs of increasing size', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
|
||||
// Test different PDF sizes
|
||||
const sizes = [
|
||||
{ pages: 1, name: '1-page', expectedTime: 100 },
|
||||
{ pages: 10, name: '10-page', expectedTime: 200 },
|
||||
{ pages: 50, name: '50-page', expectedTime: 500 },
|
||||
{ pages: 100, name: '100-page', expectedTime: 1000 }
|
||||
];
|
||||
|
||||
for (const sizeTest of sizes) {
|
||||
const sizeStartTime = performance.now();
|
||||
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
// Create multiple pages
|
||||
for (let i = 0; i < sizeTest.pages; i++) {
|
||||
const page = pdfDoc.addPage([595, 842]); // A4
|
||||
|
||||
// Add content to each page
|
||||
page.drawText(`Invoice Page ${i + 1} of ${sizeTest.pages}`, {
|
||||
x: 50,
|
||||
y: 750,
|
||||
size: 20
|
||||
});
|
||||
|
||||
// Add some graphics to increase file size
|
||||
page.drawRectangle({
|
||||
x: 50,
|
||||
y: 600,
|
||||
width: 495,
|
||||
height: 100,
|
||||
borderColor: { red: 0, green: 0, blue: 0 },
|
||||
borderWidth: 1
|
||||
});
|
||||
|
||||
// Add text content
|
||||
for (let j = 0; j < 20; j++) {
|
||||
page.drawText(`Line item ${j + 1}: Product description with details`, {
|
||||
x: 60,
|
||||
y: 580 - (j * 20),
|
||||
size: 10
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Add invoice XML
|
||||
const xmlContent = `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
|
||||
<ID>LARGE-PDF-${sizeTest.name}</ID>
|
||||
<IssueDate>2025-01-25</IssueDate>
|
||||
<Note>Test invoice for ${sizeTest.pages} page PDF</Note>
|
||||
<LineItemCount>${sizeTest.pages * 20}</LineItemCount>
|
||||
</Invoice>`;
|
||||
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(xmlContent, 'utf8'),
|
||||
'invoice.xml',
|
||||
{
|
||||
mimeType: 'application/xml',
|
||||
description: `Invoice for ${sizeTest.pages} page document`
|
||||
}
|
||||
);
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
const sizeMB = (pdfBytes.length / 1024 / 1024).toFixed(2);
|
||||
|
||||
// Test extraction performance
|
||||
const extractStartTime = performance.now();
|
||||
const einvoice = new EInvoice();
|
||||
|
||||
try {
|
||||
await einvoice.loadFromPdfBuffer(pdfBytes);
|
||||
const xmlString = einvoice.getXmlString();
|
||||
expect(xmlString).toContain(`LARGE-PDF-${sizeTest.name}`);
|
||||
|
||||
const extractTime = performance.now() - extractStartTime;
|
||||
console.log(`${sizeTest.name} (${sizeMB} MB): Extraction took ${extractTime.toFixed(2)}ms`);
|
||||
|
||||
// Check if extraction time is reasonable
|
||||
expect(extractTime).toBeLessThan(sizeTest.expectedTime);
|
||||
} catch (error) {
|
||||
console.log(`${sizeTest.name} extraction error:`, error.message);
|
||||
}
|
||||
|
||||
const sizeElapsed = performance.now() - sizeStartTime;
|
||||
performanceTracker.addMeasurement(`size-${sizeTest.name}`, sizeElapsed);
|
||||
}
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('increasing-sizes', elapsed);
|
||||
});
|
||||
|
||||
t.test('Memory usage with large PDFs', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
// Monitor memory usage
|
||||
const initialMemory = process.memoryUsage();
|
||||
console.log('Initial memory (MB):', {
|
||||
rss: (initialMemory.rss / 1024 / 1024).toFixed(2),
|
||||
heapUsed: (initialMemory.heapUsed / 1024 / 1024).toFixed(2)
|
||||
});
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
// Create a large PDF with many objects
|
||||
const pageCount = 200;
|
||||
for (let i = 0; i < pageCount; i++) {
|
||||
const page = pdfDoc.addPage();
|
||||
|
||||
// Add many small objects to increase complexity
|
||||
for (let j = 0; j < 50; j++) {
|
||||
page.drawText(`Item ${i}-${j}`, {
|
||||
x: 50 + (j % 10) * 50,
|
||||
y: 700 - Math.floor(j / 10) * 20,
|
||||
size: 8
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Add large XML attachment
|
||||
let xmlContent = '<?xml version="1.0" encoding="UTF-8"?>\n<LargeInvoice>\n';
|
||||
for (let i = 0; i < 1000; i++) {
|
||||
xmlContent += ` <LineItem number="${i}">
|
||||
<Description>Product item with long description text that increases file size</Description>
|
||||
<Quantity>10</Quantity>
|
||||
<Price>99.99</Price>
|
||||
</LineItem>\n`;
|
||||
}
|
||||
xmlContent += '</LargeInvoice>';
|
||||
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(xmlContent, 'utf8'),
|
||||
'large-invoice.xml',
|
||||
{
|
||||
mimeType: 'application/xml',
|
||||
description: 'Large invoice with many line items'
|
||||
}
|
||||
);
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
const sizeMB = (pdfBytes.length / 1024 / 1024).toFixed(2);
|
||||
console.log(`Created large PDF: ${sizeMB} MB`);
|
||||
|
||||
// Test memory usage during processing
|
||||
const einvoice = new EInvoice();
|
||||
await einvoice.loadFromPdfBuffer(pdfBytes);
|
||||
|
||||
const afterMemory = process.memoryUsage();
|
||||
console.log('After processing memory (MB):', {
|
||||
rss: (afterMemory.rss / 1024 / 1024).toFixed(2),
|
||||
heapUsed: (afterMemory.heapUsed / 1024 / 1024).toFixed(2)
|
||||
});
|
||||
|
||||
const memoryIncrease = afterMemory.heapUsed - initialMemory.heapUsed;
|
||||
console.log(`Memory increase: ${(memoryIncrease / 1024 / 1024).toFixed(2)} MB`);
|
||||
|
||||
// Force garbage collection if available
|
||||
if (global.gc) {
|
||||
global.gc();
|
||||
const gcMemory = process.memoryUsage();
|
||||
console.log('After GC memory (MB):', {
|
||||
heapUsed: (gcMemory.heapUsed / 1024 / 1024).toFixed(2)
|
||||
});
|
||||
}
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('memory-usage', elapsed);
|
||||
});
|
||||
|
||||
t.test('Streaming vs loading performance', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
|
||||
// Create a moderately large PDF
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
for (let i = 0; i < 50; i++) {
|
||||
const page = pdfDoc.addPage();
|
||||
page.drawText(`Page ${i + 1}`, { x: 50, y: 700, size: 20 });
|
||||
}
|
||||
|
||||
const xmlContent = `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Invoice><ID>STREAM-TEST</ID></Invoice>`;
|
||||
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(xmlContent, 'utf8'),
|
||||
'invoice.xml',
|
||||
{ mimeType: 'application/xml' }
|
||||
);
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
|
||||
// Test full loading
|
||||
const loadStartTime = performance.now();
|
||||
const einvoice1 = new EInvoice();
|
||||
await einvoice1.loadFromPdfBuffer(pdfBytes);
|
||||
const loadTime = performance.now() - loadStartTime;
|
||||
|
||||
console.log(`Full loading time: ${loadTime.toFixed(2)}ms`);
|
||||
|
||||
// Note: Actual streaming would require stream API support
|
||||
// This is a placeholder for streaming performance comparison
|
||||
console.log('Streaming API would potentially reduce memory usage for large files');
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('streaming-comparison', elapsed);
|
||||
});
|
||||
|
||||
t.test('Concurrent large PDF processing', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
|
||||
// Create multiple PDFs for concurrent processing
|
||||
const createPdf = async (id: string, pages: number) => {
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
for (let i = 0; i < pages; i++) {
|
||||
const page = pdfDoc.addPage();
|
||||
page.drawText(`Document ${id} - Page ${i + 1}`, { x: 50, y: 700, size: 16 });
|
||||
}
|
||||
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(`<Invoice><ID>${id}</ID></Invoice>`, 'utf8'),
|
||||
'invoice.xml',
|
||||
{ mimeType: 'application/xml' }
|
||||
);
|
||||
|
||||
return pdfDoc.save();
|
||||
};
|
||||
|
||||
// Create PDFs
|
||||
const pdfPromises = [
|
||||
createPdf('PDF-A', 30),
|
||||
createPdf('PDF-B', 40),
|
||||
createPdf('PDF-C', 50),
|
||||
createPdf('PDF-D', 60)
|
||||
];
|
||||
|
||||
const pdfs = await Promise.all(pdfPromises);
|
||||
|
||||
// Process concurrently
|
||||
const concurrentStartTime = performance.now();
|
||||
|
||||
const processPromises = pdfs.map(async (pdfBytes, index) => {
|
||||
const einvoice = new EInvoice();
|
||||
await einvoice.loadFromPdfBuffer(pdfBytes);
|
||||
return einvoice.getXmlString();
|
||||
});
|
||||
|
||||
const results = await Promise.all(processPromises);
|
||||
const concurrentTime = performance.now() - concurrentStartTime;
|
||||
|
||||
expect(results.length).toBe(4);
|
||||
results.forEach((xml, index) => {
|
||||
expect(xml).toContain(`PDF-${String.fromCharCode(65 + index)}`);
|
||||
});
|
||||
|
||||
console.log(`Concurrent processing of 4 PDFs: ${concurrentTime.toFixed(2)}ms`);
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('concurrent-processing', elapsed);
|
||||
});
|
||||
|
||||
t.test('Large PDF with complex structure', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
// Create complex structure with forms, annotations, etc.
|
||||
const formPage = pdfDoc.addPage();
|
||||
|
||||
// Add form fields (simplified - actual forms require more setup)
|
||||
formPage.drawText('Invoice Form', { x: 50, y: 750, size: 24 });
|
||||
formPage.drawRectangle({
|
||||
x: 50,
|
||||
y: 700,
|
||||
width: 200,
|
||||
height: 30,
|
||||
borderColor: { red: 0, green: 0, blue: 0.5 },
|
||||
borderWidth: 1
|
||||
});
|
||||
formPage.drawText('Invoice Number:', { x: 55, y: 710, size: 12 });
|
||||
|
||||
// Add multiple embedded files
|
||||
const attachments = [
|
||||
{ name: 'invoice.xml', size: 10000 },
|
||||
{ name: 'terms.pdf', size: 50000 },
|
||||
{ name: 'logo.png', size: 20000 }
|
||||
];
|
||||
|
||||
for (const att of attachments) {
|
||||
const content = Buffer.alloc(att.size, 'A'); // Dummy content
|
||||
await pdfDoc.attach(content, att.name, {
|
||||
mimeType: att.name.endsWith('.xml') ? 'application/xml' : 'application/octet-stream',
|
||||
description: `Attachment: ${att.name}`
|
||||
});
|
||||
}
|
||||
|
||||
// Add many pages with different content types
|
||||
for (let i = 0; i < 25; i++) {
|
||||
const page = pdfDoc.addPage();
|
||||
|
||||
// Alternate between text-heavy and graphic-heavy pages
|
||||
if (i % 2 === 0) {
|
||||
// Text-heavy page
|
||||
for (let j = 0; j < 40; j++) {
|
||||
page.drawText(`Line ${j + 1}: Lorem ipsum dolor sit amet, consectetur adipiscing elit.`, {
|
||||
x: 50,
|
||||
y: 750 - (j * 18),
|
||||
size: 10
|
||||
});
|
||||
}
|
||||
} else {
|
||||
// Graphic-heavy page
|
||||
for (let j = 0; j < 10; j++) {
|
||||
for (let k = 0; k < 10; k++) {
|
||||
page.drawRectangle({
|
||||
x: 50 + (k * 50),
|
||||
y: 700 - (j * 50),
|
||||
width: 45,
|
||||
height: 45,
|
||||
color: {
|
||||
red: Math.random(),
|
||||
green: Math.random(),
|
||||
blue: Math.random()
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
const sizeMB = (pdfBytes.length / 1024 / 1024).toFixed(2);
|
||||
console.log(`Complex PDF size: ${sizeMB} MB`);
|
||||
|
||||
// Test processing
|
||||
const processStartTime = performance.now();
|
||||
const einvoice = new EInvoice();
|
||||
|
||||
try {
|
||||
await einvoice.loadFromPdfBuffer(pdfBytes);
|
||||
const processTime = performance.now() - processStartTime;
|
||||
console.log(`Complex PDF processed in: ${processTime.toFixed(2)}ms`);
|
||||
} catch (error) {
|
||||
console.log('Complex PDF processing error:', error.message);
|
||||
}
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('complex-structure', elapsed);
|
||||
});
|
||||
|
||||
t.test('Corpus large PDF analysis', async () => {
|
||||
const startTime = performance.now();
|
||||
let largeFileCount = 0;
|
||||
let totalSize = 0;
|
||||
let processedCount = 0;
|
||||
const sizeDistribution = {
|
||||
small: 0, // < 100KB
|
||||
medium: 0, // 100KB - 1MB
|
||||
large: 0, // 1MB - 10MB
|
||||
veryLarge: 0 // > 10MB
|
||||
};
|
||||
|
||||
const files = await corpusLoader.getAllFiles();
|
||||
const pdfFiles = files.filter(f => f.endsWith('.pdf'));
|
||||
|
||||
for (const file of pdfFiles) {
|
||||
try {
|
||||
const content = await corpusLoader.readFile(file);
|
||||
const sizeMB = content.length / 1024 / 1024;
|
||||
totalSize += content.length;
|
||||
|
||||
if (content.length < 100 * 1024) {
|
||||
sizeDistribution.small++;
|
||||
} else if (content.length < 1024 * 1024) {
|
||||
sizeDistribution.medium++;
|
||||
} else if (content.length < 10 * 1024 * 1024) {
|
||||
sizeDistribution.large++;
|
||||
largeFileCount++;
|
||||
} else {
|
||||
sizeDistribution.veryLarge++;
|
||||
largeFileCount++;
|
||||
}
|
||||
|
||||
// Test large file processing
|
||||
if (sizeMB > 1) {
|
||||
const testStartTime = performance.now();
|
||||
const einvoice = new EInvoice();
|
||||
|
||||
try {
|
||||
await einvoice.loadFromPdfBuffer(content);
|
||||
const testTime = performance.now() - testStartTime;
|
||||
console.log(`Large file ${file} (${sizeMB.toFixed(2)} MB) processed in ${testTime.toFixed(2)}ms`);
|
||||
} catch (error) {
|
||||
console.log(`Large file ${file} processing failed:`, error.message);
|
||||
}
|
||||
}
|
||||
|
||||
processedCount++;
|
||||
} catch (error) {
|
||||
console.log(`Error reading ${file}:`, error.message);
|
||||
}
|
||||
}
|
||||
|
||||
const avgSize = totalSize / processedCount / 1024;
|
||||
console.log(`Corpus PDF analysis (${processedCount} files):`);
|
||||
console.log(`- Average size: ${avgSize.toFixed(2)} KB`);
|
||||
console.log(`- Large files (>1MB): ${largeFileCount}`);
|
||||
console.log('Size distribution:', sizeDistribution);
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('corpus-large-pdfs', elapsed);
|
||||
});
|
||||
|
||||
t.test('Performance degradation test', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
const processingTimes: number[] = [];
|
||||
|
||||
// Test if performance degrades with repeated operations
|
||||
for (let iteration = 0; iteration < 5; iteration++) {
|
||||
const iterStartTime = performance.now();
|
||||
|
||||
// Create PDF
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
for (let i = 0; i < 20; i++) {
|
||||
const page = pdfDoc.addPage();
|
||||
page.drawText(`Iteration ${iteration + 1} - Page ${i + 1}`, {
|
||||
x: 50,
|
||||
y: 700,
|
||||
size: 16
|
||||
});
|
||||
}
|
||||
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(`<Invoice><ID>PERF-${iteration}</ID></Invoice>`, 'utf8'),
|
||||
'invoice.xml',
|
||||
{ mimeType: 'application/xml' }
|
||||
);
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
|
||||
// Process PDF
|
||||
const einvoice = new EInvoice();
|
||||
await einvoice.loadFromPdfBuffer(pdfBytes);
|
||||
einvoice.getXmlString();
|
||||
|
||||
const iterTime = performance.now() - iterStartTime;
|
||||
processingTimes.push(iterTime);
|
||||
console.log(`Iteration ${iteration + 1}: ${iterTime.toFixed(2)}ms`);
|
||||
}
|
||||
|
||||
// Check for performance degradation
|
||||
const firstTime = processingTimes[0];
|
||||
const lastTime = processingTimes[processingTimes.length - 1];
|
||||
const degradation = ((lastTime - firstTime) / firstTime) * 100;
|
||||
|
||||
console.log(`Performance degradation: ${degradation.toFixed(2)}%`);
|
||||
expect(Math.abs(degradation)).toBeLessThan(50); // Allow up to 50% variation
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('degradation-test', elapsed);
|
||||
});
|
||||
|
||||
// Print performance summary
|
||||
performanceTracker.printSummary();
|
||||
|
||||
// Performance assertions
|
||||
const avgTime = performanceTracker.getAverageTime();
|
||||
expect(avgTime).toBeLessThan(2000); // Large PDFs may take longer
|
||||
});
|
||||
|
||||
tap.start();
|
||||
574
test/suite/einvoice_pdf-operations/test.pdf-09.corrupted-pdf.ts
Normal file
574
test/suite/einvoice_pdf-operations/test.pdf-09.corrupted-pdf.ts
Normal file
@ -0,0 +1,574 @@
|
||||
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';
|
||||
|
||||
const testTimeout = 300000; // 5 minutes timeout for PDF processing
|
||||
|
||||
// PDF-09: Corrupted PDF Recovery
|
||||
// Tests recovery mechanisms for corrupted, malformed, or partially damaged PDF files
|
||||
// including graceful error handling and data recovery strategies
|
||||
|
||||
tap.test('PDF-09: Corrupted PDF Recovery - Truncated PDF Files', async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
try {
|
||||
// Get a working PDF from corpus to create corrupted versions
|
||||
const validPdfs = await CorpusLoader.getFiles('ZUGFERD_V1');
|
||||
|
||||
if (validPdfs.length === 0) {
|
||||
tools.log('⚠ No valid PDF files found for corruption testing');
|
||||
return;
|
||||
}
|
||||
|
||||
const basePdf = validPdfs[0];
|
||||
const basePdfName = plugins.path.basename(basePdf);
|
||||
|
||||
tools.log(`Creating corrupted versions of: ${basePdfName}`);
|
||||
|
||||
// Read the original PDF
|
||||
const originalPdfBuffer = await plugins.fs.readFile(basePdf);
|
||||
const originalSize = originalPdfBuffer.length;
|
||||
|
||||
tools.log(`Original PDF size: ${(originalSize / 1024).toFixed(1)}KB`);
|
||||
|
||||
// Test different levels of truncation
|
||||
const truncationTests = [
|
||||
{ name: '90% Truncated', percentage: 0.9 },
|
||||
{ name: '75% Truncated', percentage: 0.75 },
|
||||
{ name: '50% Truncated', percentage: 0.5 },
|
||||
{ name: '25% Truncated', percentage: 0.25 },
|
||||
{ name: '10% Truncated', percentage: 0.1 }
|
||||
];
|
||||
|
||||
for (const truncationTest of truncationTests) {
|
||||
const truncatedSize = Math.floor(originalSize * truncationTest.percentage);
|
||||
const truncatedBuffer = originalPdfBuffer.subarray(0, truncatedSize);
|
||||
|
||||
const truncatedPath = plugins.path.join(process.cwd(), '.nogit', `truncated-${truncationTest.name.toLowerCase().replace(/\s+/g, '-')}.pdf`);
|
||||
await plugins.fs.ensureDir(plugins.path.dirname(truncatedPath));
|
||||
await plugins.fs.writeFile(truncatedPath, truncatedBuffer);
|
||||
|
||||
tools.log(`Testing ${truncationTest.name} (${(truncatedSize / 1024).toFixed(1)}KB)...`);
|
||||
|
||||
try {
|
||||
const invoice = new EInvoice();
|
||||
const extractionResult = await invoice.fromFile(truncatedPath);
|
||||
|
||||
if (extractionResult) {
|
||||
tools.log(` ✓ Unexpected success - managed to extract from ${truncationTest.name}`);
|
||||
|
||||
// Verify extracted content
|
||||
const xmlContent = await invoice.toXmlString();
|
||||
if (xmlContent && xmlContent.length > 50) {
|
||||
tools.log(` Extracted XML length: ${xmlContent.length} chars`);
|
||||
}
|
||||
} else {
|
||||
tools.log(` ✓ Expected failure - no extraction from ${truncationTest.name}`);
|
||||
}
|
||||
|
||||
} catch (extractionError) {
|
||||
// Expected for corrupted files
|
||||
tools.log(` ✓ Expected error for ${truncationTest.name}: ${extractionError.message.substring(0, 100)}...`);
|
||||
expect(extractionError.message).toBeTruthy();
|
||||
}
|
||||
|
||||
// Clean up
|
||||
await plugins.fs.remove(truncatedPath);
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
tools.log(`Truncated PDF test failed: ${error.message}`);
|
||||
throw error;
|
||||
}
|
||||
|
||||
const duration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdf-corrupted-truncated', duration);
|
||||
});
|
||||
|
||||
tap.test('PDF-09: Corrupted PDF Recovery - Header Corruption', async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
// Test various PDF header corruption scenarios
|
||||
const headerCorruptionTests = [
|
||||
{
|
||||
name: 'Invalid PDF Header',
|
||||
content: '%NOT-A-PDF-1.4\n%âãÏÓ\n',
|
||||
expectedError: true
|
||||
},
|
||||
{
|
||||
name: 'Missing PDF Version',
|
||||
content: '%PDF-\n%âãÏÓ\n',
|
||||
expectedError: true
|
||||
},
|
||||
{
|
||||
name: 'Corrupted Binary Marker',
|
||||
content: '%PDF-1.4\n%CORRUPTED\n',
|
||||
expectedError: true
|
||||
},
|
||||
{
|
||||
name: 'Empty PDF File',
|
||||
content: '',
|
||||
expectedError: true
|
||||
},
|
||||
{
|
||||
name: 'Only Header Line',
|
||||
content: '%PDF-1.4\n',
|
||||
expectedError: true
|
||||
},
|
||||
{
|
||||
name: 'Wrong File Extension Content',
|
||||
content: 'This is actually a text file, not a PDF',
|
||||
expectedError: true
|
||||
}
|
||||
];
|
||||
|
||||
for (const headerTest of headerCorruptionTests) {
|
||||
tools.log(`Testing ${headerTest.name}...`);
|
||||
|
||||
const corruptedPath = plugins.path.join(process.cwd(), '.nogit', `header-${headerTest.name.toLowerCase().replace(/\s+/g, '-')}.pdf`);
|
||||
await plugins.fs.ensureDir(plugins.path.dirname(corruptedPath));
|
||||
|
||||
try {
|
||||
// Create corrupted file
|
||||
await plugins.fs.writeFile(corruptedPath, headerTest.content, 'binary');
|
||||
|
||||
const invoice = new EInvoice();
|
||||
const extractionResult = await invoice.fromFile(corruptedPath);
|
||||
|
||||
if (headerTest.expectedError) {
|
||||
if (extractionResult) {
|
||||
tools.log(` ⚠ Expected error for ${headerTest.name} but extraction succeeded`);
|
||||
} else {
|
||||
tools.log(` ✓ Expected failure - no extraction from ${headerTest.name}`);
|
||||
}
|
||||
} else {
|
||||
tools.log(` ✓ ${headerTest.name}: Extraction succeeded as expected`);
|
||||
}
|
||||
|
||||
} catch (extractionError) {
|
||||
if (headerTest.expectedError) {
|
||||
tools.log(` ✓ Expected error for ${headerTest.name}: ${extractionError.message.substring(0, 80)}...`);
|
||||
expect(extractionError.message).toBeTruthy();
|
||||
} else {
|
||||
tools.log(` ✗ Unexpected error for ${headerTest.name}: ${extractionError.message}`);
|
||||
throw extractionError;
|
||||
}
|
||||
} finally {
|
||||
// Clean up
|
||||
try {
|
||||
await plugins.fs.remove(corruptedPath);
|
||||
} catch (cleanupError) {
|
||||
// Ignore cleanup errors
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const duration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdf-corrupted-header', duration);
|
||||
});
|
||||
|
||||
tap.test('PDF-09: Corrupted PDF Recovery - Random Byte Corruption', async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
try {
|
||||
const validPdfs = await CorpusLoader.getFiles('ZUGFERD_V1');
|
||||
|
||||
if (validPdfs.length === 0) {
|
||||
tools.log('⚠ No valid PDF files found for random corruption testing');
|
||||
return;
|
||||
}
|
||||
|
||||
const basePdf = validPdfs[0];
|
||||
const originalBuffer = await plugins.fs.readFile(basePdf);
|
||||
|
||||
tools.log(`Testing random byte corruption with: ${plugins.path.basename(basePdf)}`);
|
||||
|
||||
// Test different levels of random corruption
|
||||
const corruptionLevels = [
|
||||
{ name: 'Light Corruption (0.1%)', percentage: 0.001 },
|
||||
{ name: 'Medium Corruption (1%)', percentage: 0.01 },
|
||||
{ name: 'Heavy Corruption (5%)', percentage: 0.05 },
|
||||
{ name: 'Severe Corruption (10%)', percentage: 0.1 }
|
||||
];
|
||||
|
||||
for (const corruptionLevel of corruptionLevels) {
|
||||
tools.log(`Testing ${corruptionLevel.name}...`);
|
||||
|
||||
// Create corrupted version
|
||||
const corruptedBuffer = Buffer.from(originalBuffer);
|
||||
const bytesToCorrupt = Math.floor(corruptedBuffer.length * corruptionLevel.percentage);
|
||||
|
||||
for (let i = 0; i < bytesToCorrupt; i++) {
|
||||
const randomIndex = Math.floor(Math.random() * corruptedBuffer.length);
|
||||
const randomByte = Math.floor(Math.random() * 256);
|
||||
corruptedBuffer[randomIndex] = randomByte;
|
||||
}
|
||||
|
||||
const corruptedPath = plugins.path.join(process.cwd(), '.nogit', `random-${corruptionLevel.name.toLowerCase().replace(/\s+/g, '-')}.pdf`);
|
||||
await plugins.fs.ensureDir(plugins.path.dirname(corruptedPath));
|
||||
await plugins.fs.writeFile(corruptedPath, corruptedBuffer);
|
||||
|
||||
try {
|
||||
const invoice = new EInvoice();
|
||||
const extractionResult = await invoice.fromFile(corruptedPath);
|
||||
|
||||
if (extractionResult) {
|
||||
tools.log(` ✓ Resilient recovery from ${corruptionLevel.name}`);
|
||||
|
||||
// Verify extracted content quality
|
||||
const xmlContent = await invoice.toXmlString();
|
||||
if (xmlContent && xmlContent.length > 100) {
|
||||
tools.log(` Extracted ${xmlContent.length} chars of XML`);
|
||||
|
||||
// Test if XML is well-formed
|
||||
try {
|
||||
// Simple XML validation
|
||||
if (xmlContent.includes('<?xml') && xmlContent.includes('</')) {
|
||||
tools.log(` ✓ Extracted XML appears well-formed`);
|
||||
}
|
||||
} catch (xmlError) {
|
||||
tools.log(` ⚠ Extracted XML may be malformed: ${xmlError.message}`);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
tools.log(` ⚠ No extraction possible from ${corruptionLevel.name}`);
|
||||
}
|
||||
|
||||
} catch (extractionError) {
|
||||
tools.log(` ⚠ Extraction failed for ${corruptionLevel.name}: ${extractionError.message.substring(0, 80)}...`);
|
||||
|
||||
// Check if error message is helpful
|
||||
expect(extractionError.message).toBeTruthy();
|
||||
expect(extractionError.message.length).toBeGreaterThan(10);
|
||||
}
|
||||
|
||||
// Clean up
|
||||
await plugins.fs.remove(corruptedPath);
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
tools.log(`Random corruption test failed: ${error.message}`);
|
||||
throw error;
|
||||
}
|
||||
|
||||
const duration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdf-corrupted-random', duration);
|
||||
});
|
||||
|
||||
tap.test('PDF-09: Corrupted PDF Recovery - Structural Damage', async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
try {
|
||||
const validPdfs = await CorpusLoader.getFiles('ZUGFERD_V1');
|
||||
|
||||
if (validPdfs.length === 0) {
|
||||
tools.log('⚠ No valid PDF files found for structural damage testing');
|
||||
return;
|
||||
}
|
||||
|
||||
const basePdf = validPdfs[0];
|
||||
const originalContent = await plugins.fs.readFile(basePdf, 'binary');
|
||||
|
||||
tools.log(`Testing structural damage with: ${plugins.path.basename(basePdf)}`);
|
||||
|
||||
// Test different types of structural damage
|
||||
const structuralDamageTests = [
|
||||
{
|
||||
name: 'Missing xref table',
|
||||
damage: (content) => content.replace(/xref\s*\n[\s\S]*?trailer/g, 'damaged-xref')
|
||||
},
|
||||
{
|
||||
name: 'Corrupted trailer',
|
||||
damage: (content) => content.replace(/trailer\s*<<[\s\S]*?>>/g, 'damaged-trailer')
|
||||
},
|
||||
{
|
||||
name: 'Missing startxref',
|
||||
damage: (content) => content.replace(/startxref\s*\d+/g, 'damaged-startxref')
|
||||
},
|
||||
{
|
||||
name: 'Corrupted PDF objects',
|
||||
damage: (content) => content.replace(/\d+\s+\d+\s+obj/g, 'XX XX damaged')
|
||||
},
|
||||
{
|
||||
name: 'Missing EOF marker',
|
||||
damage: (content) => content.replace(/%%EOF\s*$/, 'CORRUPTED')
|
||||
}
|
||||
];
|
||||
|
||||
for (const damageTest of structuralDamageTests) {
|
||||
tools.log(`Testing ${damageTest.name}...`);
|
||||
|
||||
try {
|
||||
const damagedContent = damageTest.damage(originalContent);
|
||||
const damagedPath = plugins.path.join(process.cwd(), '.nogit', `structural-${damageTest.name.toLowerCase().replace(/\s+/g, '-')}.pdf`);
|
||||
|
||||
await plugins.fs.ensureDir(plugins.path.dirname(damagedPath));
|
||||
await plugins.fs.writeFile(damagedPath, damagedContent, 'binary');
|
||||
|
||||
const invoice = new EInvoice();
|
||||
const extractionResult = await invoice.fromFile(damagedPath);
|
||||
|
||||
if (extractionResult) {
|
||||
tools.log(` ✓ Recovered from ${damageTest.name}`);
|
||||
|
||||
// Test extracted content
|
||||
const xmlContent = await invoice.toXmlString();
|
||||
if (xmlContent && xmlContent.length > 50) {
|
||||
tools.log(` Recovered XML content: ${xmlContent.length} chars`);
|
||||
}
|
||||
} else {
|
||||
tools.log(` ⚠ No recovery possible from ${damageTest.name}`);
|
||||
}
|
||||
|
||||
// Clean up
|
||||
await plugins.fs.remove(damagedPath);
|
||||
|
||||
} catch (extractionError) {
|
||||
tools.log(` ⚠ ${damageTest.name} extraction failed: ${extractionError.message.substring(0, 80)}...`);
|
||||
expect(extractionError.message).toBeTruthy();
|
||||
}
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
tools.log(`Structural damage test failed: ${error.message}`);
|
||||
throw error;
|
||||
}
|
||||
|
||||
const duration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdf-corrupted-structural', duration);
|
||||
});
|
||||
|
||||
tap.test('PDF-09: Corrupted PDF Recovery - Attachment Corruption', async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
// Test scenarios where the XML attachment itself is corrupted
|
||||
try {
|
||||
const validPdfs = await CorpusLoader.getFiles('ZUGFERD_V1');
|
||||
|
||||
if (validPdfs.length === 0) {
|
||||
tools.log('⚠ No valid PDF files found for attachment corruption testing');
|
||||
return;
|
||||
}
|
||||
|
||||
const basePdf = validPdfs[0];
|
||||
|
||||
tools.log(`Testing attachment corruption scenarios with: ${plugins.path.basename(basePdf)}`);
|
||||
|
||||
// First, try to extract XML from the original file to understand the structure
|
||||
let originalXml = null;
|
||||
try {
|
||||
const originalInvoice = new EInvoice();
|
||||
const originalResult = await originalInvoice.fromFile(basePdf);
|
||||
|
||||
if (originalResult) {
|
||||
originalXml = await originalInvoice.toXmlString();
|
||||
tools.log(`Original XML length: ${originalXml.length} chars`);
|
||||
}
|
||||
} catch (originalError) {
|
||||
tools.log(`Could not extract original XML: ${originalError.message}`);
|
||||
}
|
||||
|
||||
// Test various attachment corruption scenarios
|
||||
const attachmentTests = [
|
||||
{
|
||||
name: 'Partial XML Loss',
|
||||
description: 'Simulate partial loss of XML attachment data'
|
||||
},
|
||||
{
|
||||
name: 'Encoding Corruption',
|
||||
description: 'Simulate character encoding corruption'
|
||||
},
|
||||
{
|
||||
name: 'Compression Corruption',
|
||||
description: 'Simulate corruption in compressed attachment streams'
|
||||
},
|
||||
{
|
||||
name: 'Multiple Attachments',
|
||||
description: 'Test handling when PDF contains multiple/conflicting XML attachments'
|
||||
}
|
||||
];
|
||||
|
||||
for (const attachmentTest of attachmentTests) {
|
||||
tools.log(`Testing ${attachmentTest.name}: ${attachmentTest.description}`);
|
||||
|
||||
try {
|
||||
const invoice = new EInvoice();
|
||||
|
||||
// Attempt extraction with error handling
|
||||
const extractionResult = await invoice.fromFile(basePdf);
|
||||
|
||||
if (extractionResult) {
|
||||
// If we got any result, test the robustness of the extraction
|
||||
const extractedXml = await invoice.toXmlString();
|
||||
|
||||
if (extractedXml) {
|
||||
// Test XML integrity
|
||||
const integrityChecks = {
|
||||
hasXmlDeclaration: extractedXml.startsWith('<?xml'),
|
||||
hasRootElement: extractedXml.includes('<') && extractedXml.includes('>'),
|
||||
hasClosingTags: extractedXml.includes('</'),
|
||||
isBalanced: (extractedXml.match(/</g) || []).length === (extractedXml.match(/>/g) || []).length
|
||||
};
|
||||
|
||||
tools.log(` XML Integrity Checks:`);
|
||||
tools.log(` Has XML Declaration: ${integrityChecks.hasXmlDeclaration}`);
|
||||
tools.log(` Has Root Element: ${integrityChecks.hasRootElement}`);
|
||||
tools.log(` Has Closing Tags: ${integrityChecks.hasClosingTags}`);
|
||||
tools.log(` Tags Balanced: ${integrityChecks.isBalanced}`);
|
||||
|
||||
if (Object.values(integrityChecks).every(check => check === true)) {
|
||||
tools.log(` ✓ ${attachmentTest.name}: XML integrity maintained`);
|
||||
} else {
|
||||
tools.log(` ⚠ ${attachmentTest.name}: XML integrity issues detected`);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
tools.log(` ⚠ ${attachmentTest.name}: No XML extracted`);
|
||||
}
|
||||
|
||||
} catch (extractionError) {
|
||||
tools.log(` ⚠ ${attachmentTest.name} extraction failed: ${extractionError.message.substring(0, 80)}...`);
|
||||
|
||||
// Verify error contains useful information
|
||||
expect(extractionError.message).toBeTruthy();
|
||||
|
||||
// Check if error suggests recovery options
|
||||
const errorMessage = extractionError.message.toLowerCase();
|
||||
if (errorMessage.includes('corrupt') ||
|
||||
errorMessage.includes('malformed') ||
|
||||
errorMessage.includes('damaged')) {
|
||||
tools.log(` ✓ Error message indicates corruption: helpful for debugging`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
tools.log(`Attachment corruption test failed: ${error.message}`);
|
||||
throw error;
|
||||
}
|
||||
|
||||
const duration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdf-corrupted-attachment', duration);
|
||||
});
|
||||
|
||||
tap.test('PDF-09: Corrupted PDF Recovery - Error Reporting Quality', async (tools) => {
|
||||
const startTime = Date.now();
|
||||
|
||||
// Test quality of error reporting for corrupted PDFs
|
||||
const errorReportingTests = [
|
||||
{
|
||||
name: 'Completely Invalid File',
|
||||
content: 'This is definitely not a PDF file at all',
|
||||
expectedErrorTypes: ['format', 'invalid', 'not-pdf']
|
||||
},
|
||||
{
|
||||
name: 'Binary Garbage',
|
||||
content: Buffer.from([0x00, 0xFF, 0xAB, 0xCD, 0xEF, 0x12, 0x34, 0x56]),
|
||||
expectedErrorTypes: ['binary', 'corrupt', 'invalid']
|
||||
},
|
||||
{
|
||||
name: 'Partial PDF Header',
|
||||
content: '%PDF-1.4\n%âãÏÓ\n1 0 obj\n<< >>\nendobj\n',
|
||||
expectedErrorTypes: ['incomplete', 'truncated', 'structure']
|
||||
}
|
||||
];
|
||||
|
||||
for (const errorTest of errorReportingTests) {
|
||||
tools.log(`Testing error reporting for: ${errorTest.name}`);
|
||||
|
||||
const corruptedPath = plugins.path.join(process.cwd(), '.nogit', `error-${errorTest.name.toLowerCase().replace(/\s+/g, '-')}.pdf`);
|
||||
await plugins.fs.ensureDir(plugins.path.dirname(corruptedPath));
|
||||
|
||||
try {
|
||||
// Create corrupted file
|
||||
if (Buffer.isBuffer(errorTest.content)) {
|
||||
await plugins.fs.writeFile(corruptedPath, errorTest.content);
|
||||
} else {
|
||||
await plugins.fs.writeFile(corruptedPath, errorTest.content, 'binary');
|
||||
}
|
||||
|
||||
const invoice = new EInvoice();
|
||||
|
||||
try {
|
||||
await invoice.fromFile(corruptedPath);
|
||||
tools.log(` ⚠ Expected error for ${errorTest.name} but operation succeeded`);
|
||||
} catch (extractionError) {
|
||||
tools.log(` ✓ Error caught for ${errorTest.name}`);
|
||||
tools.log(` Error message: ${extractionError.message}`);
|
||||
|
||||
// Analyze error message quality
|
||||
const errorMessage = extractionError.message.toLowerCase();
|
||||
const messageQuality = {
|
||||
isDescriptive: extractionError.message.length > 20,
|
||||
containsFileInfo: errorMessage.includes('pdf') || errorMessage.includes('file'),
|
||||
containsErrorType: errorTest.expectedErrorTypes.some(type => errorMessage.includes(type)),
|
||||
isActionable: errorMessage.includes('check') ||
|
||||
errorMessage.includes('verify') ||
|
||||
errorMessage.includes('ensure') ||
|
||||
errorMessage.includes('corrupt')
|
||||
};
|
||||
|
||||
tools.log(` Message Quality Analysis:`);
|
||||
tools.log(` Descriptive (>20 chars): ${messageQuality.isDescriptive}`);
|
||||
tools.log(` Contains file info: ${messageQuality.containsFileInfo}`);
|
||||
tools.log(` Contains error type: ${messageQuality.containsErrorType}`);
|
||||
tools.log(` Is actionable: ${messageQuality.isActionable}`);
|
||||
|
||||
// Error message should be helpful
|
||||
expect(messageQuality.isDescriptive).toBe(true);
|
||||
|
||||
if (messageQuality.containsFileInfo && messageQuality.isActionable) {
|
||||
tools.log(` ✓ High quality error message`);
|
||||
} else {
|
||||
tools.log(` ⚠ Error message could be more helpful`);
|
||||
}
|
||||
|
||||
// Check error object properties
|
||||
if (extractionError.code) {
|
||||
tools.log(` Error code: ${extractionError.code}`);
|
||||
}
|
||||
|
||||
if (extractionError.path) {
|
||||
tools.log(` Error path: ${extractionError.path}`);
|
||||
}
|
||||
}
|
||||
|
||||
} finally {
|
||||
// Clean up
|
||||
try {
|
||||
await plugins.fs.remove(corruptedPath);
|
||||
} catch (cleanupError) {
|
||||
// Ignore cleanup errors
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const duration = Date.now() - startTime;
|
||||
PerformanceTracker.recordMetric('pdf-corrupted-error-reporting', duration);
|
||||
});
|
||||
|
||||
tap.test('PDF-09: Performance Summary', async (tools) => {
|
||||
const operations = [
|
||||
'pdf-corrupted-truncated',
|
||||
'pdf-corrupted-header',
|
||||
'pdf-corrupted-random',
|
||||
'pdf-corrupted-structural',
|
||||
'pdf-corrupted-attachment',
|
||||
'pdf-corrupted-error-reporting'
|
||||
];
|
||||
|
||||
tools.log(`\n=== Corrupted PDF Recovery 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`);
|
||||
}
|
||||
}
|
||||
|
||||
tools.log(`\nCorrupted PDF recovery testing completed.`);
|
||||
tools.log(`Note: Most corruption tests expect failures - this is normal and indicates proper error handling.`);
|
||||
});
|
||||
@ -0,0 +1,501 @@
|
||||
import { expect, tap } from '@git.zone/tstest/tapbundle';
|
||||
import * as plugins from '../plugins.js';
|
||||
import { EInvoice } from '../../../ts/index.js';
|
||||
import { CorpusLoader } from '../corpus.loader.js';
|
||||
import { PerformanceTracker } from '../performance.tracker.js';
|
||||
|
||||
tap.test('PDF-10: PDF Signature Validation - should validate digital signatures in PDFs', async (t) => {
|
||||
// PDF-10: Verify digital signature validation and preservation
|
||||
// This test ensures signed PDFs are handled correctly
|
||||
|
||||
const performanceTracker = new PerformanceTracker('PDF-10: PDF Signature Validation');
|
||||
const corpusLoader = new CorpusLoader();
|
||||
|
||||
t.test('Detect signed PDFs', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
|
||||
// Create a PDF that simulates signature structure
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
const page = pdfDoc.addPage([595, 842]);
|
||||
page.drawText('Digitally Signed Invoice', {
|
||||
x: 50,
|
||||
y: 750,
|
||||
size: 20
|
||||
});
|
||||
|
||||
// Add signature placeholder
|
||||
page.drawRectangle({
|
||||
x: 400,
|
||||
y: 50,
|
||||
width: 150,
|
||||
height: 75,
|
||||
borderColor: { red: 0, green: 0, blue: 0 },
|
||||
borderWidth: 1
|
||||
});
|
||||
page.drawText('Digital Signature', {
|
||||
x: 420,
|
||||
y: 85,
|
||||
size: 10
|
||||
});
|
||||
page.drawText('[Signed Document]', {
|
||||
x: 420,
|
||||
y: 65,
|
||||
size: 8
|
||||
});
|
||||
|
||||
// Add invoice XML
|
||||
const xmlContent = `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
|
||||
<ID>SIGNED-001</ID>
|
||||
<IssueDate>2025-01-25</IssueDate>
|
||||
<DocumentCurrencyCode>EUR</DocumentCurrencyCode>
|
||||
<DigitalSignatureAttachment>
|
||||
<ExternalReference>
|
||||
<URI>signature.p7s</URI>
|
||||
<DocumentHash>SHA256:abc123...</DocumentHash>
|
||||
</ExternalReference>
|
||||
</DigitalSignatureAttachment>
|
||||
</Invoice>`;
|
||||
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(xmlContent, 'utf8'),
|
||||
'invoice.xml',
|
||||
{
|
||||
mimeType: 'application/xml',
|
||||
description: 'Signed invoice data'
|
||||
}
|
||||
);
|
||||
|
||||
// Note: pdf-lib doesn't support actual digital signatures
|
||||
// Real signature would require specialized libraries
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
|
||||
// Test signature detection
|
||||
const einvoice = new EInvoice();
|
||||
await einvoice.loadFromPdfBuffer(pdfBytes);
|
||||
|
||||
console.log('Created PDF with signature placeholder');
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('detect-signed', elapsed);
|
||||
});
|
||||
|
||||
t.test('Signature metadata structure', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
// Simulate signature metadata that might be found in signed PDFs
|
||||
const signatureMetadata = {
|
||||
signer: {
|
||||
name: 'John Doe',
|
||||
email: 'john.doe@company.com',
|
||||
organization: 'ACME Corporation',
|
||||
organizationUnit: 'Finance Department'
|
||||
},
|
||||
certificate: {
|
||||
issuer: 'GlobalSign CA',
|
||||
serialNumber: '01:23:45:67:89:AB:CD:EF',
|
||||
validFrom: '2024-01-01T00:00:00Z',
|
||||
validTo: '2026-01-01T00:00:00Z',
|
||||
algorithm: 'SHA256withRSA'
|
||||
},
|
||||
timestamp: {
|
||||
time: '2025-01-25T10:30:00Z',
|
||||
authority: 'GlobalSign TSA',
|
||||
hash: 'SHA256'
|
||||
},
|
||||
signatureDetails: {
|
||||
reason: 'Invoice Approval',
|
||||
location: 'Munich, Germany',
|
||||
contactInfo: '+49 89 12345678'
|
||||
}
|
||||
};
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
// Add metadata as document properties
|
||||
pdfDoc.setTitle('Signed Invoice 2025-001');
|
||||
pdfDoc.setAuthor(signatureMetadata.signer.name);
|
||||
pdfDoc.setSubject(`Signed by ${signatureMetadata.signer.organization}`);
|
||||
pdfDoc.setKeywords(['signed', 'verified', 'invoice']);
|
||||
pdfDoc.setCreator('EInvoice Signature System');
|
||||
|
||||
const page = pdfDoc.addPage();
|
||||
page.drawText('Invoice with Signature Metadata', { x: 50, y: 750, size: 18 });
|
||||
|
||||
// Display signature info on page
|
||||
let yPosition = 650;
|
||||
page.drawText('Digital Signature Information:', { x: 50, y: yPosition, size: 14 });
|
||||
yPosition -= 30;
|
||||
|
||||
page.drawText(`Signed by: ${signatureMetadata.signer.name}`, { x: 70, y: yPosition, size: 10 });
|
||||
yPosition -= 20;
|
||||
page.drawText(`Organization: ${signatureMetadata.signer.organization}`, { x: 70, y: yPosition, size: 10 });
|
||||
yPosition -= 20;
|
||||
page.drawText(`Date: ${signatureMetadata.timestamp.time}`, { x: 70, y: yPosition, size: 10 });
|
||||
yPosition -= 20;
|
||||
page.drawText(`Certificate: ${signatureMetadata.certificate.issuer}`, { x: 70, y: yPosition, size: 10 });
|
||||
yPosition -= 20;
|
||||
page.drawText(`Reason: ${signatureMetadata.signatureDetails.reason}`, { x: 70, y: yPosition, size: 10 });
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
console.log('Created PDF with signature metadata structure');
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('signature-metadata', elapsed);
|
||||
});
|
||||
|
||||
t.test('Multiple signatures handling', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
const page = pdfDoc.addPage();
|
||||
|
||||
page.drawText('Multi-Signature Invoice', { x: 50, y: 750, size: 20 });
|
||||
|
||||
// Simulate multiple signature fields
|
||||
const signatures = [
|
||||
{
|
||||
name: 'Creator Signature',
|
||||
signer: 'Invoice System',
|
||||
date: '2025-01-25T09:00:00Z',
|
||||
position: { x: 50, y: 150 }
|
||||
},
|
||||
{
|
||||
name: 'Approval Signature',
|
||||
signer: 'Finance Manager',
|
||||
date: '2025-01-25T10:00:00Z',
|
||||
position: { x: 220, y: 150 }
|
||||
},
|
||||
{
|
||||
name: 'Verification Signature',
|
||||
signer: 'Auditor',
|
||||
date: '2025-01-25T11:00:00Z',
|
||||
position: { x: 390, y: 150 }
|
||||
}
|
||||
];
|
||||
|
||||
// Draw signature boxes
|
||||
signatures.forEach(sig => {
|
||||
page.drawRectangle({
|
||||
x: sig.position.x,
|
||||
y: sig.position.y,
|
||||
width: 150,
|
||||
height: 80,
|
||||
borderColor: { red: 0, green: 0, blue: 0 },
|
||||
borderWidth: 1
|
||||
});
|
||||
|
||||
page.drawText(sig.name, {
|
||||
x: sig.position.x + 10,
|
||||
y: sig.position.y + 60,
|
||||
size: 10
|
||||
});
|
||||
|
||||
page.drawText(sig.signer, {
|
||||
x: sig.position.x + 10,
|
||||
y: sig.position.y + 40,
|
||||
size: 8
|
||||
});
|
||||
|
||||
page.drawText(sig.date, {
|
||||
x: sig.position.x + 10,
|
||||
y: sig.position.y + 20,
|
||||
size: 8
|
||||
});
|
||||
});
|
||||
|
||||
// Add invoice with signature references
|
||||
const xmlContent = `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
|
||||
<ID>MULTI-SIG-001</ID>
|
||||
<Signature>
|
||||
<ID>SIG-1</ID>
|
||||
<SignatoryParty>
|
||||
<PartyName><Name>Invoice System</Name></PartyName>
|
||||
</SignatoryParty>
|
||||
</Signature>
|
||||
<Signature>
|
||||
<ID>SIG-2</ID>
|
||||
<SignatoryParty>
|
||||
<PartyName><Name>Finance Manager</Name></PartyName>
|
||||
</SignatoryParty>
|
||||
</Signature>
|
||||
<Signature>
|
||||
<ID>SIG-3</ID>
|
||||
<SignatoryParty>
|
||||
<PartyName><Name>Auditor</Name></PartyName>
|
||||
</SignatoryParty>
|
||||
</Signature>
|
||||
</Invoice>`;
|
||||
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(xmlContent, 'utf8'),
|
||||
'invoice.xml',
|
||||
{ mimeType: 'application/xml' }
|
||||
);
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
console.log('Created PDF with multiple signature placeholders');
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('multiple-signatures', elapsed);
|
||||
});
|
||||
|
||||
t.test('Signature validation status', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
// Simulate different signature validation statuses
|
||||
const validationStatuses = [
|
||||
{ status: 'VALID', color: { red: 0, green: 0.5, blue: 0 }, message: 'Signature Valid' },
|
||||
{ status: 'INVALID', color: { red: 0.8, green: 0, blue: 0 }, message: 'Signature Invalid' },
|
||||
{ status: 'UNKNOWN', color: { red: 0.5, green: 0.5, blue: 0 }, message: 'Signature Unknown' },
|
||||
{ status: 'EXPIRED', color: { red: 0.8, green: 0.4, blue: 0 }, message: 'Certificate Expired' }
|
||||
];
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
|
||||
for (const valStatus of validationStatuses) {
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
const page = pdfDoc.addPage();
|
||||
|
||||
page.drawText(`Invoice - Signature ${valStatus.status}`, {
|
||||
x: 50,
|
||||
y: 750,
|
||||
size: 20
|
||||
});
|
||||
|
||||
// Draw status indicator
|
||||
page.drawRectangle({
|
||||
x: 450,
|
||||
y: 740,
|
||||
width: 100,
|
||||
height: 30,
|
||||
color: valStatus.color,
|
||||
borderColor: { red: 0, green: 0, blue: 0 },
|
||||
borderWidth: 1
|
||||
});
|
||||
|
||||
page.drawText(valStatus.message, {
|
||||
x: 460,
|
||||
y: 750,
|
||||
size: 10,
|
||||
color: { red: 1, green: 1, blue: 1 }
|
||||
});
|
||||
|
||||
const xmlContent = `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Invoice>
|
||||
<ID>SIG-${valStatus.status}</ID>
|
||||
<SignatureValidation>
|
||||
<Status>${valStatus.status}</Status>
|
||||
<Message>${valStatus.message}</Message>
|
||||
</SignatureValidation>
|
||||
</Invoice>`;
|
||||
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(xmlContent, 'utf8'),
|
||||
'invoice.xml',
|
||||
{ mimeType: 'application/xml' }
|
||||
);
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
console.log(`Created PDF with signature status: ${valStatus.status}`);
|
||||
}
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('validation-status', elapsed);
|
||||
});
|
||||
|
||||
t.test('Signature preservation during operations', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
|
||||
// Create original "signed" PDF
|
||||
const originalPdf = await PDFDocument.create();
|
||||
originalPdf.setTitle('Original Signed Document');
|
||||
originalPdf.setAuthor('Original Signer');
|
||||
originalPdf.setSubject('This document has been digitally signed');
|
||||
|
||||
const page = originalPdf.addPage();
|
||||
page.drawText('Original Signed Invoice', { x: 50, y: 750, size: 20 });
|
||||
|
||||
// Add signature visual
|
||||
page.drawRectangle({
|
||||
x: 400,
|
||||
y: 50,
|
||||
width: 150,
|
||||
height: 75,
|
||||
borderColor: { red: 0, green: 0.5, blue: 0 },
|
||||
borderWidth: 2
|
||||
});
|
||||
page.drawText('✓ Digitally Signed', {
|
||||
x: 420,
|
||||
y: 85,
|
||||
size: 12,
|
||||
color: { red: 0, green: 0.5, blue: 0 }
|
||||
});
|
||||
|
||||
const originalBytes = await originalPdf.save();
|
||||
|
||||
// Process through EInvoice
|
||||
const einvoice = new EInvoice();
|
||||
|
||||
// Add new XML while preserving signature
|
||||
const xmlContent = `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Invoice>
|
||||
<ID>PRESERVE-SIG-001</ID>
|
||||
<Note>Added to signed document</Note>
|
||||
</Invoice>`;
|
||||
|
||||
try {
|
||||
await einvoice.loadFromPdfBuffer(originalBytes);
|
||||
|
||||
// In a real implementation, this would need to preserve signatures
|
||||
console.log('Note: Adding content to signed PDFs typically invalidates signatures');
|
||||
console.log('Incremental updates would be needed to preserve signature validity');
|
||||
} catch (error) {
|
||||
console.log('Signature preservation challenge:', error.message);
|
||||
}
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('signature-preservation', elapsed);
|
||||
});
|
||||
|
||||
t.test('Timestamp validation', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
const page = pdfDoc.addPage();
|
||||
page.drawText('Time-stamped Invoice', { x: 50, y: 750, size: 20 });
|
||||
|
||||
// Simulate timestamp information
|
||||
const timestamps = [
|
||||
{
|
||||
type: 'Document Creation',
|
||||
time: '2025-01-25T09:00:00Z',
|
||||
authority: 'Internal TSA'
|
||||
},
|
||||
{
|
||||
type: 'Signature Timestamp',
|
||||
time: '2025-01-25T10:30:00Z',
|
||||
authority: 'Qualified TSA Provider'
|
||||
},
|
||||
{
|
||||
type: 'Archive Timestamp',
|
||||
time: '2025-01-25T11:00:00Z',
|
||||
authority: 'Long-term Archive TSA'
|
||||
}
|
||||
];
|
||||
|
||||
let yPos = 650;
|
||||
page.drawText('Timestamp Information:', { x: 50, y: yPos, size: 14 });
|
||||
|
||||
timestamps.forEach(ts => {
|
||||
yPos -= 30;
|
||||
page.drawText(`${ts.type}:`, { x: 70, y: yPos, size: 10 });
|
||||
yPos -= 20;
|
||||
page.drawText(`Time: ${ts.time}`, { x: 90, y: yPos, size: 9 });
|
||||
yPos -= 15;
|
||||
page.drawText(`TSA: ${ts.authority}`, { x: 90, y: yPos, size: 9 });
|
||||
});
|
||||
|
||||
const xmlContent = `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Invoice>
|
||||
<ID>TIMESTAMP-001</ID>
|
||||
<Timestamps>
|
||||
${timestamps.map(ts => `
|
||||
<Timestamp type="${ts.type}">
|
||||
<Time>${ts.time}</Time>
|
||||
<Authority>${ts.authority}</Authority>
|
||||
</Timestamp>`).join('')}
|
||||
</Timestamps>
|
||||
</Invoice>`;
|
||||
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(xmlContent, 'utf8'),
|
||||
'invoice.xml',
|
||||
{ mimeType: 'application/xml' }
|
||||
);
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
console.log('Created PDF with timestamp information');
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('timestamp-validation', elapsed);
|
||||
});
|
||||
|
||||
t.test('Corpus signed PDF detection', async () => {
|
||||
const startTime = performance.now();
|
||||
let signedCount = 0;
|
||||
let processedCount = 0;
|
||||
const signatureIndicators: string[] = [];
|
||||
|
||||
const files = await corpusLoader.getAllFiles();
|
||||
const pdfFiles = files.filter(f => f.endsWith('.pdf'));
|
||||
|
||||
// Check PDFs for signature indicators
|
||||
const sampleSize = Math.min(50, pdfFiles.length);
|
||||
const sample = pdfFiles.slice(0, sampleSize);
|
||||
|
||||
for (const file of sample) {
|
||||
try {
|
||||
const content = await corpusLoader.readFile(file);
|
||||
|
||||
// Look for signature indicators in PDF content
|
||||
const pdfString = content.toString('binary');
|
||||
const indicators = [
|
||||
'/Type /Sig',
|
||||
'/ByteRange',
|
||||
'/SubFilter',
|
||||
'/adbe.pkcs7',
|
||||
'/ETSI.CAdES',
|
||||
'SignatureField',
|
||||
'DigitalSignature'
|
||||
];
|
||||
|
||||
let hasSignature = false;
|
||||
for (const indicator of indicators) {
|
||||
if (pdfString.includes(indicator)) {
|
||||
hasSignature = true;
|
||||
if (!signatureIndicators.includes(indicator)) {
|
||||
signatureIndicators.push(indicator);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (hasSignature) {
|
||||
signedCount++;
|
||||
console.log(`Potential signed PDF: ${file}`);
|
||||
}
|
||||
|
||||
processedCount++;
|
||||
} catch (error) {
|
||||
console.log(`Error checking ${file}:`, error.message);
|
||||
}
|
||||
}
|
||||
|
||||
console.log(`Corpus signature analysis (${processedCount} PDFs):`);
|
||||
console.log(`- PDFs with signature indicators: ${signedCount}`);
|
||||
console.log('Signature indicators found:', signatureIndicators);
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('corpus-signed-pdfs', elapsed);
|
||||
});
|
||||
|
||||
// Print performance summary
|
||||
performanceTracker.printSummary();
|
||||
|
||||
// Performance assertions
|
||||
const avgTime = performanceTracker.getAverageTime();
|
||||
expect(avgTime).toBeLessThan(300); // Signature operations should be reasonably fast
|
||||
});
|
||||
|
||||
tap.start();
|
||||
@ -0,0 +1,535 @@
|
||||
import { expect, tap } from '@git.zone/tstest/tapbundle';
|
||||
import * as plugins from '../plugins.js';
|
||||
import { EInvoice } from '../../../ts/index.js';
|
||||
import { CorpusLoader } from '../corpus.loader.js';
|
||||
import { PerformanceTracker } from '../performance.tracker.js';
|
||||
|
||||
tap.test('PDF-11: PDF/A Compliance - should ensure PDF/A standard compliance', async (t) => {
|
||||
// PDF-11: Verify PDF/A compliance for long-term archiving
|
||||
// This test ensures PDFs meet PDF/A standards for electronic invoicing
|
||||
|
||||
const performanceTracker = new PerformanceTracker('PDF-11: PDF/A Compliance');
|
||||
const corpusLoader = new CorpusLoader();
|
||||
|
||||
t.test('Create PDF/A-3 compliant document', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument, PDFName } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
// PDF/A-3 allows embedded files (required for ZUGFeRD/Factur-X)
|
||||
// Set PDF/A identification
|
||||
pdfDoc.setTitle('PDF/A-3 Compliant Invoice');
|
||||
pdfDoc.setAuthor('EInvoice System');
|
||||
pdfDoc.setSubject('Electronic Invoice with embedded XML');
|
||||
pdfDoc.setKeywords(['PDF/A-3', 'ZUGFeRD', 'Factur-X', 'invoice']);
|
||||
pdfDoc.setCreator('EInvoice PDF/A Generator');
|
||||
pdfDoc.setProducer('PDFLib with PDF/A-3 compliance');
|
||||
|
||||
// Add required metadata for PDF/A
|
||||
const creationDate = new Date('2025-01-25T10:00:00Z');
|
||||
const modDate = new Date('2025-01-25T10:00:00Z');
|
||||
pdfDoc.setCreationDate(creationDate);
|
||||
pdfDoc.setModificationDate(modDate);
|
||||
|
||||
// Create page with required elements for PDF/A
|
||||
const page = pdfDoc.addPage([595, 842]); // A4
|
||||
|
||||
// Use embedded fonts (required for PDF/A)
|
||||
const helveticaFont = await pdfDoc.embedFont('Helvetica');
|
||||
|
||||
// Add content
|
||||
page.drawText('PDF/A-3 Compliant Invoice', {
|
||||
x: 50,
|
||||
y: 750,
|
||||
size: 20,
|
||||
font: helveticaFont
|
||||
});
|
||||
|
||||
page.drawText('Invoice Number: INV-2025-001', {
|
||||
x: 50,
|
||||
y: 700,
|
||||
size: 12,
|
||||
font: helveticaFont
|
||||
});
|
||||
|
||||
page.drawText('This document complies with PDF/A-3 standard', {
|
||||
x: 50,
|
||||
y: 650,
|
||||
size: 10,
|
||||
font: helveticaFont
|
||||
});
|
||||
|
||||
// Add required OutputIntent for PDF/A
|
||||
// Note: pdf-lib doesn't directly support OutputIntent
|
||||
// In production, a specialized library would be needed
|
||||
|
||||
// Embed invoice XML (allowed in PDF/A-3)
|
||||
const xmlContent = `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<rsm:CrossIndustryInvoice xmlns:rsm="urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100">
|
||||
<rsm:ExchangedDocument>
|
||||
<ram:ID xmlns:ram="urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100">INV-2025-001</ram:ID>
|
||||
<ram:TypeCode xmlns:ram="urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100">380</ram:TypeCode>
|
||||
<ram:IssueDateTime xmlns:ram="urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100">
|
||||
<udt:DateTimeString xmlns:udt="urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100" format="102">20250125</udt:DateTimeString>
|
||||
</ram:IssueDateTime>
|
||||
</rsm:ExchangedDocument>
|
||||
</rsm:CrossIndustryInvoice>`;
|
||||
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(xmlContent, 'utf8'),
|
||||
'invoice.xml',
|
||||
{
|
||||
mimeType: 'application/xml',
|
||||
description: 'ZUGFeRD invoice data',
|
||||
afRelationship: plugins.AFRelationship.Data,
|
||||
creationDate: creationDate,
|
||||
modificationDate: modDate
|
||||
}
|
||||
);
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
|
||||
// Verify basic structure
|
||||
expect(pdfBytes.length).toBeGreaterThan(0);
|
||||
console.log('Created PDF/A-3 structure (full compliance requires specialized tools)');
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('pdfa3-creation', elapsed);
|
||||
});
|
||||
|
||||
t.test('PDF/A-1b compliance check', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
// PDF/A-1b: Basic compliance (visual appearance preservation)
|
||||
pdfDoc.setTitle('PDF/A-1b Test Document');
|
||||
pdfDoc.setCreationDate(new Date());
|
||||
|
||||
const page = pdfDoc.addPage();
|
||||
|
||||
// PDF/A-1b requirements:
|
||||
// - All fonts must be embedded
|
||||
// - No transparency
|
||||
// - No JavaScript
|
||||
// - No audio/video
|
||||
// - No encryption
|
||||
// - Proper color space definition
|
||||
|
||||
const helveticaFont = await pdfDoc.embedFont('Helvetica');
|
||||
|
||||
page.drawText('PDF/A-1b Compliant Document', {
|
||||
x: 50,
|
||||
y: 750,
|
||||
size: 16,
|
||||
font: helveticaFont,
|
||||
color: { red: 0, green: 0, blue: 0 } // RGB color space
|
||||
});
|
||||
|
||||
// Add text without transparency
|
||||
page.drawText('No transparency allowed in PDF/A-1b', {
|
||||
x: 50,
|
||||
y: 700,
|
||||
size: 12,
|
||||
font: helveticaFont,
|
||||
color: { red: 0, green: 0, blue: 0 },
|
||||
opacity: 1.0 // Full opacity required
|
||||
});
|
||||
|
||||
// Draw rectangle without transparency
|
||||
page.drawRectangle({
|
||||
x: 50,
|
||||
y: 600,
|
||||
width: 200,
|
||||
height: 50,
|
||||
color: { red: 0.9, green: 0.9, blue: 0.9 },
|
||||
borderColor: { red: 0, green: 0, blue: 0 },
|
||||
borderWidth: 1,
|
||||
opacity: 1.0
|
||||
});
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
|
||||
// Check for PDF/A-1b violations
|
||||
const pdfString = pdfBytes.toString('binary');
|
||||
|
||||
// Check for prohibited features
|
||||
const violations = [];
|
||||
if (pdfString.includes('/JS')) violations.push('JavaScript detected');
|
||||
if (pdfString.includes('/Launch')) violations.push('External launch action detected');
|
||||
if (pdfString.includes('/Sound')) violations.push('Sound annotation detected');
|
||||
if (pdfString.includes('/Movie')) violations.push('Movie annotation detected');
|
||||
if (pdfString.includes('/Encrypt')) violations.push('Encryption detected');
|
||||
|
||||
console.log('PDF/A-1b compliance check:');
|
||||
if (violations.length === 0) {
|
||||
console.log('No obvious violations detected');
|
||||
} else {
|
||||
console.log('Potential violations:', violations);
|
||||
}
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('pdfa1b-compliance', elapsed);
|
||||
});
|
||||
|
||||
t.test('PDF/A metadata requirements', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
// Required XMP metadata for PDF/A
|
||||
const xmpMetadata = `<?xpacket begin="" id="W5M0MpCehiHzreSzNTczkc9d"?>
|
||||
<x:xmpmeta xmlns:x="adobe:ns:meta/">
|
||||
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
|
||||
<rdf:Description rdf:about=""
|
||||
xmlns:dc="http://purl.org/dc/elements/1.1/"
|
||||
xmlns:pdfaid="http://www.aiim.org/pdfa/ns/id/"
|
||||
xmlns:xmp="http://ns.adobe.com/xap/1.0/"
|
||||
xmlns:pdf="http://ns.adobe.com/pdf/1.3/">
|
||||
<dc:title>
|
||||
<rdf:Alt>
|
||||
<rdf:li xml:lang="x-default">PDF/A Compliant Invoice</rdf:li>
|
||||
</rdf:Alt>
|
||||
</dc:title>
|
||||
<dc:creator>
|
||||
<rdf:Seq>
|
||||
<rdf:li>EInvoice System</rdf:li>
|
||||
</rdf:Seq>
|
||||
</dc:creator>
|
||||
<dc:description>
|
||||
<rdf:Alt>
|
||||
<rdf:li xml:lang="x-default">Invoice with PDF/A compliance</rdf:li>
|
||||
</rdf:Alt>
|
||||
</dc:description>
|
||||
<pdfaid:part>3</pdfaid:part>
|
||||
<pdfaid:conformance>B</pdfaid:conformance>
|
||||
<xmp:CreateDate>2025-01-25T10:00:00Z</xmp:CreateDate>
|
||||
<xmp:ModifyDate>2025-01-25T10:00:00Z</xmp:ModifyDate>
|
||||
<xmp:MetadataDate>2025-01-25T10:00:00Z</xmp:MetadataDate>
|
||||
<pdf:Producer>EInvoice PDF/A Generator</pdf:Producer>
|
||||
</rdf:Description>
|
||||
</rdf:RDF>
|
||||
</x:xmpmeta>
|
||||
<?xpacket end="w"?>`;
|
||||
|
||||
// Set standard metadata
|
||||
pdfDoc.setTitle('PDF/A Compliant Invoice');
|
||||
pdfDoc.setAuthor('EInvoice System');
|
||||
pdfDoc.setSubject('Invoice with PDF/A compliance');
|
||||
pdfDoc.setKeywords(['PDF/A', 'invoice', 'compliant']);
|
||||
|
||||
const page = pdfDoc.addPage();
|
||||
page.drawText('Document with PDF/A Metadata', { x: 50, y: 750, size: 16 });
|
||||
|
||||
// Note: pdf-lib doesn't support direct XMP metadata embedding
|
||||
// This would require post-processing or a specialized library
|
||||
|
||||
console.log('PDF/A metadata structure defined (requires specialized tools for embedding)');
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('pdfa-metadata', elapsed);
|
||||
});
|
||||
|
||||
t.test('Color space compliance', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
const page = pdfDoc.addPage();
|
||||
|
||||
// PDF/A requires proper color space definitions
|
||||
// Test different color spaces
|
||||
|
||||
// Device RGB (most common for screen display)
|
||||
page.drawText('Device RGB Color Space', {
|
||||
x: 50,
|
||||
y: 750,
|
||||
size: 14,
|
||||
color: { red: 0.8, green: 0.2, blue: 0.2 }
|
||||
});
|
||||
|
||||
// Grayscale
|
||||
page.drawText('Device Gray Color Space', {
|
||||
x: 50,
|
||||
y: 700,
|
||||
size: 14,
|
||||
color: { red: 0.5, green: 0.5, blue: 0.5 }
|
||||
});
|
||||
|
||||
// Test color accuracy
|
||||
const colors = [
|
||||
{ name: 'Pure Red', rgb: { red: 1, green: 0, blue: 0 } },
|
||||
{ name: 'Pure Green', rgb: { red: 0, green: 1, blue: 0 } },
|
||||
{ name: 'Pure Blue', rgb: { red: 0, green: 0, blue: 1 } },
|
||||
{ name: 'Black', rgb: { red: 0, green: 0, blue: 0 } },
|
||||
{ name: 'White', rgb: { red: 1, green: 1, blue: 1 } }
|
||||
];
|
||||
|
||||
let yPos = 600;
|
||||
colors.forEach(color => {
|
||||
page.drawRectangle({
|
||||
x: 50,
|
||||
y: yPos,
|
||||
width: 30,
|
||||
height: 20,
|
||||
color: color.rgb
|
||||
});
|
||||
|
||||
page.drawText(color.name, {
|
||||
x: 90,
|
||||
y: yPos + 5,
|
||||
size: 10,
|
||||
color: { red: 0, green: 0, blue: 0 }
|
||||
});
|
||||
|
||||
yPos -= 30;
|
||||
});
|
||||
|
||||
// Add OutputIntent description
|
||||
page.drawText('OutputIntent: sRGB IEC61966-2.1', {
|
||||
x: 50,
|
||||
y: 400,
|
||||
size: 10,
|
||||
color: { red: 0, green: 0, blue: 0 }
|
||||
});
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
console.log('Created PDF with color space definitions for PDF/A');
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('color-space', elapsed);
|
||||
});
|
||||
|
||||
t.test('Font embedding compliance', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
// PDF/A requires all fonts to be embedded
|
||||
const page = pdfDoc.addPage();
|
||||
|
||||
// Embed standard fonts
|
||||
const helvetica = await pdfDoc.embedFont('Helvetica');
|
||||
const helveticaBold = await pdfDoc.embedFont('Helvetica-Bold');
|
||||
const helveticaOblique = await pdfDoc.embedFont('Helvetica-Oblique');
|
||||
const timesRoman = await pdfDoc.embedFont('Times-Roman');
|
||||
const courier = await pdfDoc.embedFont('Courier');
|
||||
|
||||
// Use embedded fonts
|
||||
page.drawText('Helvetica Regular (Embedded)', {
|
||||
x: 50,
|
||||
y: 750,
|
||||
size: 14,
|
||||
font: helvetica
|
||||
});
|
||||
|
||||
page.drawText('Helvetica Bold (Embedded)', {
|
||||
x: 50,
|
||||
y: 720,
|
||||
size: 14,
|
||||
font: helveticaBold
|
||||
});
|
||||
|
||||
page.drawText('Helvetica Oblique (Embedded)', {
|
||||
x: 50,
|
||||
y: 690,
|
||||
size: 14,
|
||||
font: helveticaOblique
|
||||
});
|
||||
|
||||
page.drawText('Times Roman (Embedded)', {
|
||||
x: 50,
|
||||
y: 660,
|
||||
size: 14,
|
||||
font: timesRoman
|
||||
});
|
||||
|
||||
page.drawText('Courier (Embedded)', {
|
||||
x: 50,
|
||||
y: 630,
|
||||
size: 14,
|
||||
font: courier
|
||||
});
|
||||
|
||||
// Test font subset embedding
|
||||
page.drawText('Font Subset Test: €£¥§¶•', {
|
||||
x: 50,
|
||||
y: 580,
|
||||
size: 14,
|
||||
font: helvetica
|
||||
});
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
|
||||
// Check font embedding
|
||||
const pdfString = pdfBytes.toString('binary');
|
||||
const fontCount = (pdfString.match(/\/Type\s*\/Font/g) || []).length;
|
||||
console.log(`Embedded fonts count: ${fontCount}`);
|
||||
|
||||
expect(fontCount).toBeGreaterThan(0);
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('font-embedding', elapsed);
|
||||
});
|
||||
|
||||
t.test('PDF/A-3 with ZUGFeRD attachment', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument, AFRelationship } = plugins;
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
// Configure for ZUGFeRD/Factur-X compliance
|
||||
pdfDoc.setTitle('ZUGFeRD Invoice PDF/A-3');
|
||||
pdfDoc.setAuthor('ZUGFeRD Generator');
|
||||
pdfDoc.setSubject('Electronic Invoice with embedded XML');
|
||||
pdfDoc.setKeywords(['ZUGFeRD', 'PDF/A-3', 'Factur-X', 'electronic invoice']);
|
||||
pdfDoc.setCreator('EInvoice ZUGFeRD Module');
|
||||
|
||||
const page = pdfDoc.addPage();
|
||||
const helvetica = await pdfDoc.embedFont('Helvetica');
|
||||
|
||||
// Invoice header
|
||||
page.drawText('RECHNUNG / INVOICE', {
|
||||
x: 50,
|
||||
y: 750,
|
||||
size: 20,
|
||||
font: helvetica
|
||||
});
|
||||
|
||||
page.drawText('Rechnungsnummer / Invoice No: 2025-001', {
|
||||
x: 50,
|
||||
y: 700,
|
||||
size: 12,
|
||||
font: helvetica
|
||||
});
|
||||
|
||||
page.drawText('Rechnungsdatum / Invoice Date: 25.01.2025', {
|
||||
x: 50,
|
||||
y: 680,
|
||||
size: 12,
|
||||
font: helvetica
|
||||
});
|
||||
|
||||
// ZUGFeRD XML attachment
|
||||
const zugferdXml = `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<rsm:CrossIndustryInvoice xmlns:rsm="urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100"
|
||||
xmlns:ram="urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100"
|
||||
xmlns:udt="urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100">
|
||||
<rsm:ExchangedDocumentContext>
|
||||
<ram:GuidelineSpecifiedDocumentContextParameter>
|
||||
<ram:ID>urn:cen.eu:en16931:2017#conformant#urn:zugferd.de:2p1:extended</ram:ID>
|
||||
</ram:GuidelineSpecifiedDocumentContextParameter>
|
||||
</rsm:ExchangedDocumentContext>
|
||||
<rsm:ExchangedDocument>
|
||||
<ram:ID>2025-001</ram:ID>
|
||||
<ram:TypeCode>380</ram:TypeCode>
|
||||
<ram:IssueDateTime>
|
||||
<udt:DateTimeString format="102">20250125</udt:DateTimeString>
|
||||
</ram:IssueDateTime>
|
||||
</rsm:ExchangedDocument>
|
||||
</rsm:CrossIndustryInvoice>`;
|
||||
|
||||
// Attach with proper relationship for ZUGFeRD
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(zugferdXml, 'utf8'),
|
||||
'zugferd-invoice.xml',
|
||||
{
|
||||
mimeType: 'application/xml',
|
||||
description: 'ZUGFeRD Invoice Data',
|
||||
afRelationship: AFRelationship.Data
|
||||
}
|
||||
);
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
|
||||
// Test loading
|
||||
const einvoice = new EInvoice();
|
||||
await einvoice.loadFromPdfBuffer(pdfBytes);
|
||||
|
||||
console.log('Created PDF/A-3 compliant ZUGFeRD invoice');
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('zugferd-pdfa3', elapsed);
|
||||
});
|
||||
|
||||
t.test('Corpus PDF/A compliance check', async () => {
|
||||
const startTime = performance.now();
|
||||
let pdfaCount = 0;
|
||||
let processedCount = 0;
|
||||
const complianceIndicators = {
|
||||
'PDF/A identification': 0,
|
||||
'Embedded fonts': 0,
|
||||
'No encryption': 0,
|
||||
'Metadata present': 0,
|
||||
'Color space defined': 0
|
||||
};
|
||||
|
||||
const files = await corpusLoader.getAllFiles();
|
||||
const pdfFiles = files.filter(f => f.endsWith('.pdf'));
|
||||
|
||||
// Sample PDFs for PDF/A compliance indicators
|
||||
const sampleSize = Math.min(40, pdfFiles.length);
|
||||
const sample = pdfFiles.slice(0, sampleSize);
|
||||
|
||||
for (const file of sample) {
|
||||
try {
|
||||
const content = await corpusLoader.readFile(file);
|
||||
const pdfString = content.toString('binary');
|
||||
|
||||
// Check for PDF/A indicators
|
||||
let isPdfA = false;
|
||||
|
||||
if (pdfString.includes('pdfaid:part') || pdfString.includes('PDF/A')) {
|
||||
isPdfA = true;
|
||||
complianceIndicators['PDF/A identification']++;
|
||||
}
|
||||
|
||||
if (pdfString.includes('/Type /Font') && pdfString.includes('/FontFile')) {
|
||||
complianceIndicators['Embedded fonts']++;
|
||||
}
|
||||
|
||||
if (!pdfString.includes('/Encrypt')) {
|
||||
complianceIndicators['No encryption']++;
|
||||
}
|
||||
|
||||
if (pdfString.includes('/Metadata') || pdfString.includes('xmpmeta')) {
|
||||
complianceIndicators['Metadata present']++;
|
||||
}
|
||||
|
||||
if (pdfString.includes('/OutputIntent') || pdfString.includes('/ColorSpace')) {
|
||||
complianceIndicators['Color space defined']++;
|
||||
}
|
||||
|
||||
if (isPdfA) {
|
||||
pdfaCount++;
|
||||
console.log(`Potential PDF/A file: ${file}`);
|
||||
}
|
||||
|
||||
processedCount++;
|
||||
} catch (error) {
|
||||
console.log(`Error checking ${file}:`, error.message);
|
||||
}
|
||||
}
|
||||
|
||||
console.log(`Corpus PDF/A analysis (${processedCount} PDFs):`);
|
||||
console.log(`- Potential PDF/A files: ${pdfaCount}`);
|
||||
console.log('Compliance indicators:', complianceIndicators);
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('corpus-pdfa', elapsed);
|
||||
});
|
||||
|
||||
// Print performance summary
|
||||
performanceTracker.printSummary();
|
||||
|
||||
// Performance assertions
|
||||
const avgTime = performanceTracker.getAverageTime();
|
||||
expect(avgTime).toBeLessThan(400); // PDF/A operations may take longer
|
||||
});
|
||||
|
||||
tap.start();
|
||||
@ -0,0 +1,566 @@
|
||||
import { expect, tap } from '@git.zone/tstest/tapbundle';
|
||||
import * as plugins from '../plugins.js';
|
||||
import { EInvoice } from '../../../ts/index.js';
|
||||
import { CorpusLoader } from '../corpus.loader.js';
|
||||
import { PerformanceTracker } from '../performance.tracker.js';
|
||||
|
||||
tap.test('PDF-12: PDF Version Compatibility - should handle different PDF versions correctly', async (t) => {
|
||||
// PDF-12: Verify compatibility across different PDF versions (1.3 - 1.7)
|
||||
// This test ensures the system works with various PDF specifications
|
||||
|
||||
const performanceTracker = new PerformanceTracker('PDF-12: PDF Version Compatibility');
|
||||
const corpusLoader = new CorpusLoader();
|
||||
|
||||
t.test('Create PDFs with different version headers', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
|
||||
// Test different PDF versions
|
||||
const versions = [
|
||||
{ version: '1.3', features: 'Basic PDF features, Acrobat 4.x compatible' },
|
||||
{ version: '1.4', features: 'Transparency, Acrobat 5.x compatible' },
|
||||
{ version: '1.5', features: 'Object streams, Acrobat 6.x compatible' },
|
||||
{ version: '1.6', features: 'OpenType fonts, Acrobat 7.x compatible' },
|
||||
{ version: '1.7', features: 'XFA forms, ISO 32000-1:2008 standard' }
|
||||
];
|
||||
|
||||
for (const ver of versions) {
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
// Note: pdf-lib doesn't allow direct version setting
|
||||
// PDFs are typically created as 1.7 by default
|
||||
|
||||
pdfDoc.setTitle(`PDF Version ${ver.version} Test`);
|
||||
pdfDoc.setSubject(ver.features);
|
||||
|
||||
const page = pdfDoc.addPage([595, 842]);
|
||||
|
||||
page.drawText(`PDF Version ${ver.version}`, {
|
||||
x: 50,
|
||||
y: 750,
|
||||
size: 24
|
||||
});
|
||||
|
||||
page.drawText(`Features: ${ver.features}`, {
|
||||
x: 50,
|
||||
y: 700,
|
||||
size: 12
|
||||
});
|
||||
|
||||
// Add version-specific content
|
||||
if (parseFloat(ver.version) >= 1.4) {
|
||||
// Transparency (PDF 1.4+)
|
||||
page.drawRectangle({
|
||||
x: 50,
|
||||
y: 600,
|
||||
width: 200,
|
||||
height: 50,
|
||||
color: { red: 0, green: 0, blue: 1 },
|
||||
opacity: 0.5 // Transparency
|
||||
});
|
||||
}
|
||||
|
||||
// Add invoice XML
|
||||
const xmlContent = `<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
|
||||
<ID>PDF-VER-${ver.version}</ID>
|
||||
<Note>Test invoice for PDF ${ver.version}</Note>
|
||||
<PDFVersion>${ver.version}</PDFVersion>
|
||||
</Invoice>`;
|
||||
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(xmlContent, 'utf8'),
|
||||
'invoice.xml',
|
||||
{
|
||||
mimeType: 'application/xml',
|
||||
description: `Invoice for PDF ${ver.version}`
|
||||
}
|
||||
);
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
|
||||
// Check version in output
|
||||
const pdfString = pdfBytes.toString('binary').substring(0, 100);
|
||||
console.log(`Created PDF (declared as ${ver.version}), header: ${pdfString.substring(0, 8)}`);
|
||||
|
||||
// Test processing
|
||||
const einvoice = new EInvoice();
|
||||
try {
|
||||
await einvoice.loadFromPdfBuffer(pdfBytes);
|
||||
const xml = einvoice.getXmlString();
|
||||
expect(xml).toContain(`PDF-VER-${ver.version}`);
|
||||
} catch (error) {
|
||||
console.log(`Version ${ver.version} processing error:`, error.message);
|
||||
}
|
||||
}
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('version-creation', elapsed);
|
||||
});
|
||||
|
||||
t.test('Feature compatibility across versions', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
|
||||
// Test version-specific features
|
||||
const featureTests = [
|
||||
{
|
||||
name: 'Basic Features (1.3+)',
|
||||
test: async (pdfDoc: any) => {
|
||||
const page = pdfDoc.addPage();
|
||||
// Basic text and graphics
|
||||
page.drawText('Basic Text', { x: 50, y: 700, size: 14 });
|
||||
page.drawLine({
|
||||
start: { x: 50, y: 680 },
|
||||
end: { x: 200, y: 680 },
|
||||
thickness: 1
|
||||
});
|
||||
}
|
||||
},
|
||||
{
|
||||
name: 'Transparency (1.4+)',
|
||||
test: async (pdfDoc: any) => {
|
||||
const page = pdfDoc.addPage();
|
||||
// Overlapping transparent rectangles
|
||||
page.drawRectangle({
|
||||
x: 50,
|
||||
y: 600,
|
||||
width: 100,
|
||||
height: 100,
|
||||
color: { red: 1, green: 0, blue: 0 },
|
||||
opacity: 0.5
|
||||
});
|
||||
page.drawRectangle({
|
||||
x: 100,
|
||||
y: 650,
|
||||
width: 100,
|
||||
height: 100,
|
||||
color: { red: 0, green: 0, blue: 1 },
|
||||
opacity: 0.5
|
||||
});
|
||||
}
|
||||
},
|
||||
{
|
||||
name: 'Embedded Files (1.4+)',
|
||||
test: async (pdfDoc: any) => {
|
||||
// Multiple embedded files
|
||||
await pdfDoc.attach(
|
||||
Buffer.from('<data>Primary</data>', 'utf8'),
|
||||
'primary.xml',
|
||||
{ mimeType: 'application/xml' }
|
||||
);
|
||||
await pdfDoc.attach(
|
||||
Buffer.from('<data>Secondary</data>', 'utf8'),
|
||||
'secondary.xml',
|
||||
{ mimeType: 'application/xml' }
|
||||
);
|
||||
}
|
||||
},
|
||||
{
|
||||
name: 'Unicode Support (1.5+)',
|
||||
test: async (pdfDoc: any) => {
|
||||
const page = pdfDoc.addPage();
|
||||
page.drawText('Unicode: 中文 العربية ελληνικά', {
|
||||
x: 50,
|
||||
y: 600,
|
||||
size: 14
|
||||
});
|
||||
}
|
||||
}
|
||||
];
|
||||
|
||||
for (const feature of featureTests) {
|
||||
console.log(`Testing: ${feature.name}`);
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
pdfDoc.setTitle(feature.name);
|
||||
await feature.test(pdfDoc);
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
expect(pdfBytes.length).toBeGreaterThan(0);
|
||||
}
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('feature-compatibility', elapsed);
|
||||
});
|
||||
|
||||
t.test('Cross-version attachment compatibility', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument, AFRelationship } = plugins;
|
||||
|
||||
// Test attachment features across versions
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
pdfDoc.setTitle('Cross-Version Attachment Test');
|
||||
const page = pdfDoc.addPage();
|
||||
page.drawText('PDF with Various Attachment Features', { x: 50, y: 750, size: 16 });
|
||||
|
||||
// Test different attachment configurations
|
||||
const attachmentTests = [
|
||||
{
|
||||
name: 'Simple attachment (1.3+)',
|
||||
file: 'simple.xml',
|
||||
content: '<invoice><id>SIMPLE</id></invoice>',
|
||||
options: { mimeType: 'application/xml' }
|
||||
},
|
||||
{
|
||||
name: 'With description (1.4+)',
|
||||
file: 'described.xml',
|
||||
content: '<invoice><id>DESCRIBED</id></invoice>',
|
||||
options: {
|
||||
mimeType: 'application/xml',
|
||||
description: 'Invoice with description'
|
||||
}
|
||||
},
|
||||
{
|
||||
name: 'With relationship (1.7+)',
|
||||
file: 'related.xml',
|
||||
content: '<invoice><id>RELATED</id></invoice>',
|
||||
options: {
|
||||
mimeType: 'application/xml',
|
||||
description: 'Invoice with AFRelationship',
|
||||
afRelationship: AFRelationship.Data
|
||||
}
|
||||
},
|
||||
{
|
||||
name: 'With dates (1.4+)',
|
||||
file: 'dated.xml',
|
||||
content: '<invoice><id>DATED</id></invoice>',
|
||||
options: {
|
||||
mimeType: 'application/xml',
|
||||
description: 'Invoice with timestamps',
|
||||
creationDate: new Date('2025-01-01'),
|
||||
modificationDate: new Date('2025-01-25')
|
||||
}
|
||||
}
|
||||
];
|
||||
|
||||
let yPos = 700;
|
||||
for (const test of attachmentTests) {
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(test.content, 'utf8'),
|
||||
test.file,
|
||||
test.options
|
||||
);
|
||||
|
||||
page.drawText(`✓ ${test.name}`, { x: 70, y: yPos, size: 10 });
|
||||
yPos -= 20;
|
||||
}
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
|
||||
// Test extraction
|
||||
const einvoice = new EInvoice();
|
||||
await einvoice.loadFromPdfBuffer(pdfBytes);
|
||||
console.log('Cross-version attachment test completed');
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('attachment-compatibility', elapsed);
|
||||
});
|
||||
|
||||
t.test('Backward compatibility', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
|
||||
// Create PDF with only features from older versions
|
||||
const pdfDoc = await PDFDocument.create();
|
||||
|
||||
pdfDoc.setTitle('Backward Compatible PDF');
|
||||
pdfDoc.setAuthor('Legacy System');
|
||||
pdfDoc.setSubject('PDF 1.3 Compatible Invoice');
|
||||
|
||||
const page = pdfDoc.addPage([612, 792]); // US Letter
|
||||
|
||||
// Use only basic features available in PDF 1.3
|
||||
const helvetica = await pdfDoc.embedFont('Helvetica');
|
||||
|
||||
// Simple text
|
||||
page.drawText('Legacy Compatible Invoice', {
|
||||
x: 72,
|
||||
y: 720,
|
||||
size: 18,
|
||||
font: helvetica,
|
||||
color: { red: 0, green: 0, blue: 0 }
|
||||
});
|
||||
|
||||
// Basic shapes without transparency
|
||||
page.drawRectangle({
|
||||
x: 72,
|
||||
y: 600,
|
||||
width: 468,
|
||||
height: 100,
|
||||
borderColor: { red: 0, green: 0, blue: 0 },
|
||||
borderWidth: 1
|
||||
});
|
||||
|
||||
// Simple lines
|
||||
page.drawLine({
|
||||
start: { x: 72, y: 650 },
|
||||
end: { x: 540, y: 650 },
|
||||
thickness: 1,
|
||||
color: { red: 0, green: 0, blue: 0 }
|
||||
});
|
||||
|
||||
// Basic invoice data (no advanced features)
|
||||
const invoiceLines = [
|
||||
'Invoice Number: 2025-001',
|
||||
'Date: January 25, 2025',
|
||||
'Amount: $1,234.56',
|
||||
'Status: PAID'
|
||||
];
|
||||
|
||||
let yPos = 620;
|
||||
invoiceLines.forEach(line => {
|
||||
page.drawText(line, {
|
||||
x: 80,
|
||||
y: yPos,
|
||||
size: 12,
|
||||
font: helvetica,
|
||||
color: { red: 0, green: 0, blue: 0 }
|
||||
});
|
||||
yPos -= 20;
|
||||
});
|
||||
|
||||
// Simple XML attachment
|
||||
const xmlContent = `<?xml version="1.0"?>
|
||||
<invoice>
|
||||
<number>2025-001</number>
|
||||
<date>2025-01-25</date>
|
||||
<amount>1234.56</amount>
|
||||
</invoice>`;
|
||||
|
||||
await pdfDoc.attach(
|
||||
Buffer.from(xmlContent, 'utf8'),
|
||||
'invoice.xml',
|
||||
{ mimeType: 'text/xml' } // Basic MIME type
|
||||
);
|
||||
|
||||
const pdfBytes = await pdfDoc.save();
|
||||
|
||||
// Verify it can be processed
|
||||
const einvoice = new EInvoice();
|
||||
await einvoice.loadFromPdfBuffer(pdfBytes);
|
||||
|
||||
console.log('Created backward compatible PDF (1.3 features only)');
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('backward-compatibility', elapsed);
|
||||
});
|
||||
|
||||
t.test('Version detection in corpus', async () => {
|
||||
const startTime = performance.now();
|
||||
let processedCount = 0;
|
||||
const versionStats: Record<string, number> = {};
|
||||
const featureStats = {
|
||||
transparency: 0,
|
||||
embeddedFiles: 0,
|
||||
javascript: 0,
|
||||
forms: 0,
|
||||
compression: 0
|
||||
};
|
||||
|
||||
const files = await corpusLoader.getAllFiles();
|
||||
const pdfFiles = files.filter(f => f.endsWith('.pdf'));
|
||||
|
||||
// Analyze PDF versions in corpus
|
||||
const sampleSize = Math.min(50, pdfFiles.length);
|
||||
const sample = pdfFiles.slice(0, sampleSize);
|
||||
|
||||
for (const file of sample) {
|
||||
try {
|
||||
const content = await corpusLoader.readFile(file);
|
||||
const pdfString = content.toString('binary');
|
||||
|
||||
// Extract PDF version from header
|
||||
const versionMatch = pdfString.match(/%PDF-(\d\.\d)/);
|
||||
if (versionMatch) {
|
||||
const version = versionMatch[1];
|
||||
versionStats[version] = (versionStats[version] || 0) + 1;
|
||||
}
|
||||
|
||||
// Check for version-specific features
|
||||
if (pdfString.includes('/Group') && pdfString.includes('/S /Transparency')) {
|
||||
featureStats.transparency++;
|
||||
}
|
||||
|
||||
if (pdfString.includes('/EmbeddedFiles')) {
|
||||
featureStats.embeddedFiles++;
|
||||
}
|
||||
|
||||
if (pdfString.includes('/JS') || pdfString.includes('/JavaScript')) {
|
||||
featureStats.javascript++;
|
||||
}
|
||||
|
||||
if (pdfString.includes('/AcroForm')) {
|
||||
featureStats.forms++;
|
||||
}
|
||||
|
||||
if (pdfString.includes('/Filter') && pdfString.includes('/FlateDecode')) {
|
||||
featureStats.compression++;
|
||||
}
|
||||
|
||||
processedCount++;
|
||||
} catch (error) {
|
||||
console.log(`Error analyzing ${file}:`, error.message);
|
||||
}
|
||||
}
|
||||
|
||||
console.log(`Corpus version analysis (${processedCount} PDFs):`);
|
||||
console.log('PDF versions found:', versionStats);
|
||||
console.log('Feature usage:', featureStats);
|
||||
|
||||
// Most common version
|
||||
const sortedVersions = Object.entries(versionStats).sort((a, b) => b[1] - a[1]);
|
||||
if (sortedVersions.length > 0) {
|
||||
console.log(`Most common version: PDF ${sortedVersions[0][0]} (${sortedVersions[0][1]} files)`);
|
||||
}
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('corpus-versions', elapsed);
|
||||
});
|
||||
|
||||
t.test('Version upgrade scenarios', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
|
||||
// Simulate upgrading PDF from older to newer version
|
||||
console.log('Testing version upgrade scenarios:');
|
||||
|
||||
// Create "old" PDF (simulated)
|
||||
const oldPdf = await PDFDocument.create();
|
||||
oldPdf.setTitle('Old PDF (1.3 style)');
|
||||
|
||||
const page1 = oldPdf.addPage();
|
||||
page1.drawText('Original Document', { x: 50, y: 700, size: 16 });
|
||||
page1.drawText('Created with PDF 1.3 features only', { x: 50, y: 650, size: 12 });
|
||||
|
||||
const oldPdfBytes = await oldPdf.save();
|
||||
|
||||
// "Upgrade" by loading and adding new features
|
||||
const upgradedPdf = await PDFDocument.load(oldPdfBytes);
|
||||
upgradedPdf.setTitle('Upgraded PDF (1.7 features)');
|
||||
|
||||
// Add new page with modern features
|
||||
const page2 = upgradedPdf.addPage();
|
||||
page2.drawText('Upgraded Content', { x: 50, y: 700, size: 16 });
|
||||
|
||||
// Add transparency (1.4+ feature)
|
||||
page2.drawRectangle({
|
||||
x: 50,
|
||||
y: 600,
|
||||
width: 200,
|
||||
height: 50,
|
||||
color: { red: 0, green: 0.5, blue: 1 },
|
||||
opacity: 0.7
|
||||
});
|
||||
|
||||
// Add multiple attachments (enhanced in later versions)
|
||||
await upgradedPdf.attach(
|
||||
Buffer.from('<data>New attachment</data>', 'utf8'),
|
||||
'new_data.xml',
|
||||
{
|
||||
mimeType: 'application/xml',
|
||||
description: 'Added during upgrade',
|
||||
afRelationship: plugins.AFRelationship.Supplement
|
||||
}
|
||||
);
|
||||
|
||||
const upgradedBytes = await upgradedPdf.save();
|
||||
console.log(`Original size: ${oldPdfBytes.length} bytes`);
|
||||
console.log(`Upgraded size: ${upgradedBytes.length} bytes`);
|
||||
|
||||
// Test both versions work
|
||||
const einvoice = new EInvoice();
|
||||
await einvoice.loadFromPdfBuffer(upgradedBytes);
|
||||
console.log('Version upgrade test completed');
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('version-upgrade', elapsed);
|
||||
});
|
||||
|
||||
t.test('Compatibility edge cases', async () => {
|
||||
const startTime = performance.now();
|
||||
|
||||
const { PDFDocument } = plugins;
|
||||
|
||||
// Test edge cases that might cause compatibility issues
|
||||
const edgeCases = [
|
||||
{
|
||||
name: 'Empty pages',
|
||||
test: async () => {
|
||||
const pdf = await PDFDocument.create();
|
||||
pdf.addPage(); // Empty page
|
||||
pdf.addPage(); // Another empty page
|
||||
return pdf.save();
|
||||
}
|
||||
},
|
||||
{
|
||||
name: 'Very long text',
|
||||
test: async () => {
|
||||
const pdf = await PDFDocument.create();
|
||||
const page = pdf.addPage();
|
||||
const longText = 'Lorem ipsum '.repeat(1000);
|
||||
page.drawText(longText.substring(0, 1000), { x: 50, y: 700, size: 8 });
|
||||
return pdf.save();
|
||||
}
|
||||
},
|
||||
{
|
||||
name: 'Special characters in metadata',
|
||||
test: async () => {
|
||||
const pdf = await PDFDocument.create();
|
||||
pdf.setTitle('Test™ © ® € £ ¥');
|
||||
pdf.setAuthor('Müller & Associés');
|
||||
pdf.setSubject('Invoice (2025) <test>');
|
||||
pdf.addPage();
|
||||
return pdf.save();
|
||||
}
|
||||
},
|
||||
{
|
||||
name: 'Maximum attachments',
|
||||
test: async () => {
|
||||
const pdf = await PDFDocument.create();
|
||||
pdf.addPage();
|
||||
// Add multiple small attachments
|
||||
for (let i = 0; i < 10; i++) {
|
||||
await pdf.attach(
|
||||
Buffer.from(`<item>${i}</item>`, 'utf8'),
|
||||
`file${i}.xml`,
|
||||
{ mimeType: 'application/xml' }
|
||||
);
|
||||
}
|
||||
return pdf.save();
|
||||
}
|
||||
}
|
||||
];
|
||||
|
||||
for (const edgeCase of edgeCases) {
|
||||
try {
|
||||
console.log(`Testing edge case: ${edgeCase.name}`);
|
||||
const pdfBytes = await edgeCase.test();
|
||||
|
||||
const einvoice = new EInvoice();
|
||||
await einvoice.loadFromPdfBuffer(pdfBytes);
|
||||
console.log(`✓ ${edgeCase.name} - Success`);
|
||||
} catch (error) {
|
||||
console.log(`✗ ${edgeCase.name} - Failed:`, error.message);
|
||||
}
|
||||
}
|
||||
|
||||
const elapsed = performance.now() - startTime;
|
||||
performanceTracker.addMeasurement('edge-cases', elapsed);
|
||||
});
|
||||
|
||||
// Print performance summary
|
||||
performanceTracker.printSummary();
|
||||
|
||||
// Performance assertions
|
||||
const avgTime = performanceTracker.getAverageTime();
|
||||
expect(avgTime).toBeLessThan(500); // Version compatibility tests may vary
|
||||
});
|
||||
|
||||
tap.start();
|
||||
Reference in New Issue
Block a user