475 lines
16 KiB
TypeScript
475 lines
16 KiB
TypeScript
import { expect, tap } from '@git.zone/tstest/tapbundle';
|
|
import * as einvoice from '../../../ts/index.js';
|
|
import * as plugins from '../../plugins.js';
|
|
import { CorpusLoader } from '../../helpers/corpus.loader.js';
|
|
import { PerformanceTracker } from '../../helpers/performance.tracker.js';
|
|
|
|
tap.test('PARSE-01: Basic XML structure parsing', async () => {
|
|
const testCases = [
|
|
{
|
|
name: 'Minimal invoice',
|
|
xml: '<?xml version="1.0" encoding="UTF-8"?>\n<invoice><id>TEST-001</id></invoice>',
|
|
expectedId: null // Generic invoice element not recognized
|
|
},
|
|
{
|
|
name: 'Invoice with namespaces',
|
|
xml: `<?xml version="1.0" encoding="UTF-8"?>
|
|
<ubl:Invoice xmlns:ubl="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2" xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2">
|
|
<cbc:ID>TEST-002</cbc:ID>
|
|
</ubl:Invoice>`,
|
|
expectedId: 'TEST-002'
|
|
},
|
|
{
|
|
name: 'XRechnung UBL invoice',
|
|
xml: `<?xml version="1.0" encoding="UTF-8"?>
|
|
<ubl:Invoice xmlns:ubl="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2" xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2" xmlns:cac="urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2">
|
|
<cbc:ID>TEST-003</cbc:ID>
|
|
<cbc:IssueDate>2024-01-01</cbc:IssueDate>
|
|
<cac:AccountingSupplierParty>
|
|
<cac:Party>
|
|
<cac:PartyName>
|
|
<cbc:Name>Test Supplier</cbc:Name>
|
|
</cac:PartyName>
|
|
<cac:PostalAddress>
|
|
<cbc:CityName>Berlin</cbc:CityName>
|
|
<cbc:PostalZone>10115</cbc:PostalZone>
|
|
<cac:Country>
|
|
<cbc:IdentificationCode>DE</cbc:IdentificationCode>
|
|
</cac:Country>
|
|
</cac:PostalAddress>
|
|
</cac:Party>
|
|
</cac:AccountingSupplierParty>
|
|
<cac:AccountingCustomerParty>
|
|
<cac:Party>
|
|
<cac:PartyName>
|
|
<cbc:Name>Test Customer</cbc:Name>
|
|
</cac:PartyName>
|
|
<cac:PostalAddress>
|
|
<cbc:CityName>Munich</cbc:CityName>
|
|
<cbc:PostalZone>80331</cbc:PostalZone>
|
|
<cac:Country>
|
|
<cbc:IdentificationCode>DE</cbc:IdentificationCode>
|
|
</cac:Country>
|
|
</cac:PostalAddress>
|
|
</cac:Party>
|
|
</cac:AccountingCustomerParty>
|
|
<cac:InvoiceLine>
|
|
<cbc:ID>1</cbc:ID>
|
|
<cbc:InvoicedQuantity unitCode="EA">1</cbc:InvoicedQuantity>
|
|
<cbc:LineExtensionAmount currencyID="EUR">100.00</cbc:LineExtensionAmount>
|
|
<cac:Item>
|
|
<cbc:Name>Test Product</cbc:Name>
|
|
</cac:Item>
|
|
<cac:Price>
|
|
<cbc:PriceAmount currencyID="EUR">100.00</cbc:PriceAmount>
|
|
</cac:Price>
|
|
</cac:InvoiceLine>
|
|
<cac:LegalMonetaryTotal>
|
|
<cbc:TaxInclusiveAmount currencyID="EUR">119.00</cbc:TaxInclusiveAmount>
|
|
</cac:LegalMonetaryTotal>
|
|
</ubl:Invoice>`,
|
|
expectedId: 'TEST-003'
|
|
}
|
|
];
|
|
|
|
for (const testCase of testCases) {
|
|
const { result, metric } = await PerformanceTracker.track(
|
|
'xml-parsing',
|
|
async () => {
|
|
const invoice = new einvoice.EInvoice();
|
|
|
|
try {
|
|
await invoice.fromXmlString(testCase.xml);
|
|
return {
|
|
success: true,
|
|
id: invoice.id,
|
|
hasFrom: !!invoice.from,
|
|
hasTo: !!invoice.to,
|
|
itemCount: invoice.items?.length || 0
|
|
};
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: error.message
|
|
};
|
|
}
|
|
}
|
|
);
|
|
|
|
console.log(`${testCase.name}: ${result.success ? '✓' : '✗'}`);
|
|
|
|
if (testCase.expectedId !== null) {
|
|
if (result.success) {
|
|
expect(result.id).toEqual(testCase.expectedId);
|
|
console.log(` ID: ${result.id}`);
|
|
console.log(` Has supplier: ${result.hasFrom}`);
|
|
console.log(` Has customer: ${result.hasTo}`);
|
|
console.log(` Item count: ${result.itemCount}`);
|
|
} else {
|
|
console.log(` Error: ${result.error}`);
|
|
}
|
|
}
|
|
|
|
console.log(` Parse time: ${metric.duration.toFixed(2)}ms`);
|
|
}
|
|
});
|
|
|
|
tap.test('PARSE-01: Character encoding handling', async () => {
|
|
const encodingTests = [
|
|
{
|
|
name: 'UTF-8 with special characters',
|
|
xml: `<?xml version="1.0" encoding="UTF-8"?>
|
|
<ubl:Invoice xmlns:ubl="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2" xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2">
|
|
<cbc:ID>UTF8-TEST</cbc:ID>
|
|
<cbc:Note>Special chars: äöü ñ € « » 中文</cbc:Note>
|
|
</ubl:Invoice>`,
|
|
expectedNote: 'Special chars: äöü ñ € « » 中文'
|
|
},
|
|
{
|
|
name: 'ISO-8859-1 declaration',
|
|
xml: `<?xml version="1.0" encoding="ISO-8859-1"?>
|
|
<ubl:Invoice xmlns:ubl="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2" xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2">
|
|
<cbc:ID>ISO-TEST</cbc:ID>
|
|
<cbc:Note>Latin-1 chars: àèìòù</cbc:Note>
|
|
</ubl:Invoice>`,
|
|
expectedNote: 'Latin-1 chars: àèìòù'
|
|
}
|
|
];
|
|
|
|
for (const test of encodingTests) {
|
|
const { result } = await PerformanceTracker.track(
|
|
'encoding-test',
|
|
async () => {
|
|
const invoice = new einvoice.EInvoice();
|
|
|
|
try {
|
|
await invoice.fromXmlString(test.xml);
|
|
return {
|
|
success: true,
|
|
notes: invoice.notes,
|
|
id: invoice.id
|
|
};
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: error.message
|
|
};
|
|
}
|
|
}
|
|
);
|
|
|
|
console.log(`${test.name}: ${result.success ? '✓' : '✗'}`);
|
|
|
|
if (result.success) {
|
|
expect(result.notes).toBeDefined();
|
|
if (result.notes && result.notes.length > 0) {
|
|
expect(result.notes[0]).toEqual(test.expectedNote);
|
|
console.log(` Note preserved: ${result.notes[0]}`);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
tap.test('PARSE-01: Namespace handling', async () => {
|
|
const namespaceTests = [
|
|
{
|
|
name: 'Multiple namespace declarations',
|
|
xml: `<?xml version="1.0" encoding="UTF-8"?>
|
|
<rsm:CrossIndustryInvoice
|
|
xmlns:rsm="urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100"
|
|
xmlns:qdt="urn:un:unece:uncefact:data:standard:QualifiedDataType:100"
|
|
xmlns:ram="urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100"
|
|
xmlns:xs="http://www.w3.org/2001/XMLSchema"
|
|
xmlns:udt="urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100">
|
|
<rsm:ExchangedDocumentContext>
|
|
<ram:GuidelineSpecifiedDocumentContextParameter>
|
|
<ram:ID>urn:cen.eu:en16931:2017#conformant#urn:factur-x.eu:1p0:extended</ram:ID>
|
|
</ram:GuidelineSpecifiedDocumentContextParameter>
|
|
</rsm:ExchangedDocumentContext>
|
|
<rsm:ExchangedDocument>
|
|
<ram:ID>NS-TEST-001</ram:ID>
|
|
</rsm:ExchangedDocument>
|
|
</rsm:CrossIndustryInvoice>`,
|
|
expectedFormat: einvoice.InvoiceFormat.FACTURX,
|
|
expectedId: 'NS-TEST-001'
|
|
},
|
|
{
|
|
name: 'Default namespace',
|
|
xml: `<?xml version="1.0" encoding="UTF-8"?>
|
|
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
|
|
<ID xmlns="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2">DEFAULT-NS-TEST</ID>
|
|
</Invoice>`,
|
|
expectedFormat: einvoice.InvoiceFormat.UBL,
|
|
expectedId: 'DEFAULT-NS-TEST'
|
|
}
|
|
];
|
|
|
|
for (const test of namespaceTests) {
|
|
const { result } = await PerformanceTracker.track(
|
|
'namespace-test',
|
|
async () => {
|
|
const invoice = new einvoice.EInvoice();
|
|
|
|
try {
|
|
await invoice.fromXmlString(test.xml);
|
|
return {
|
|
success: true,
|
|
format: invoice.getFormat(),
|
|
id: invoice.id
|
|
};
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: error.message
|
|
};
|
|
}
|
|
}
|
|
);
|
|
|
|
console.log(`${test.name}: ${result.success ? '✓' : '✗'}`);
|
|
|
|
if (result.success) {
|
|
expect(result.format).toEqual(test.expectedFormat);
|
|
expect(result.id).toEqual(test.expectedId);
|
|
console.log(` Detected format: ${einvoice.InvoiceFormat[result.format]}`);
|
|
console.log(` ID: ${result.id}`);
|
|
}
|
|
}
|
|
});
|
|
|
|
tap.test('PARSE-01: Large XML file parsing', async () => {
|
|
// Generate a large invoice with many line items
|
|
const generateLargeInvoice = (lineCount: number): string => {
|
|
const lines = [];
|
|
for (let i = 1; i <= lineCount; i++) {
|
|
lines.push(`
|
|
<cac:InvoiceLine>
|
|
<cbc:ID>${i}</cbc:ID>
|
|
<cbc:InvoicedQuantity unitCode="EA">${i}</cbc:InvoicedQuantity>
|
|
<cbc:LineExtensionAmount currencyID="EUR">${(i * 10).toFixed(2)}</cbc:LineExtensionAmount>
|
|
<cac:Item>
|
|
<cbc:Name>Product ${i}</cbc:Name>
|
|
<cbc:Description>Description for product ${i} with some additional text to make it larger</cbc:Description>
|
|
</cac:Item>
|
|
<cac:Price>
|
|
<cbc:PriceAmount currencyID="EUR">10.00</cbc:PriceAmount>
|
|
</cac:Price>
|
|
</cac:InvoiceLine>`);
|
|
}
|
|
|
|
return `<?xml version="1.0" encoding="UTF-8"?>
|
|
<ubl:Invoice xmlns:ubl="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2"
|
|
xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2"
|
|
xmlns:cac="urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2">
|
|
<cbc:ID>LARGE-INVOICE-${lineCount}</cbc:ID>
|
|
<cbc:IssueDate>2024-01-01</cbc:IssueDate>
|
|
<cac:AccountingSupplierParty>
|
|
<cac:Party>
|
|
<cac:PartyName>
|
|
<cbc:Name>Large Supplier Inc</cbc:Name>
|
|
</cac:PartyName>
|
|
<cac:PostalAddress>
|
|
<cbc:CityName>Berlin</cbc:CityName>
|
|
<cbc:PostalZone>10115</cbc:PostalZone>
|
|
<cac:Country>
|
|
<cbc:IdentificationCode>DE</cbc:IdentificationCode>
|
|
</cac:Country>
|
|
</cac:PostalAddress>
|
|
</cac:Party>
|
|
</cac:AccountingSupplierParty>
|
|
<cac:AccountingCustomerParty>
|
|
<cac:Party>
|
|
<cac:PartyName>
|
|
<cbc:Name>Large Customer Corp</cbc:Name>
|
|
</cac:PartyName>
|
|
<cac:PostalAddress>
|
|
<cbc:CityName>Munich</cbc:CityName>
|
|
<cbc:PostalZone>80331</cbc:PostalZone>
|
|
<cac:Country>
|
|
<cbc:IdentificationCode>DE</cbc:IdentificationCode>
|
|
</cac:Country>
|
|
</cac:PostalAddress>
|
|
</cac:Party>
|
|
</cac:AccountingCustomerParty>
|
|
${lines.join('')}
|
|
</ubl:Invoice>`;
|
|
};
|
|
|
|
const sizes = [10, 100, 1000];
|
|
|
|
for (const size of sizes) {
|
|
const xml = generateLargeInvoice(size);
|
|
const xmlSize = Buffer.byteLength(xml, 'utf-8') / 1024; // KB
|
|
|
|
const { result, metric } = await PerformanceTracker.track(
|
|
`parse-${size}-lines`,
|
|
async () => {
|
|
const invoice = new einvoice.EInvoice();
|
|
|
|
try {
|
|
await invoice.fromXmlString(xml);
|
|
return {
|
|
success: true,
|
|
itemCount: invoice.items?.length || 0,
|
|
memoryUsed: metric?.memory?.used || 0
|
|
};
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: error.message
|
|
};
|
|
}
|
|
}
|
|
);
|
|
|
|
console.log(`Parse ${size} line items (${xmlSize.toFixed(1)}KB): ${result.success ? '✓' : '✗'}`);
|
|
|
|
if (result.success) {
|
|
expect(result.itemCount).toEqual(size);
|
|
console.log(` Items parsed: ${result.itemCount}`);
|
|
console.log(` Parse time: ${metric.duration.toFixed(2)}ms`);
|
|
console.log(` Memory used: ${(metric.memory.used / 1024 / 1024).toFixed(2)}MB`);
|
|
console.log(` Speed: ${(xmlSize / metric.duration * 1000).toFixed(2)}KB/s`);
|
|
}
|
|
}
|
|
});
|
|
|
|
tap.test('PARSE-01: Real corpus file parsing', async () => {
|
|
// Try to load some real files from the corpus
|
|
const testFiles = [
|
|
{ category: 'UBL_XMLRECHNUNG', file: 'XRECHNUNG_Einfach.ubl.xml' },
|
|
{ category: 'CII_XMLRECHNUNG', file: 'XRECHNUNG_Einfach.cii.xml' },
|
|
{ category: 'ZUGFERDV2_CORRECT', file: null } // Will use first available
|
|
];
|
|
|
|
for (const testFile of testFiles) {
|
|
try {
|
|
let xmlContent: string;
|
|
|
|
if (testFile.file) {
|
|
xmlContent = await CorpusLoader.loadTestFile(testFile.category, testFile.file);
|
|
} else {
|
|
const files = await CorpusLoader.getCorpusFiles(testFile.category);
|
|
if (files.length > 0) {
|
|
xmlContent = await CorpusLoader.loadTestFile(testFile.category, files[0]);
|
|
} else {
|
|
console.log(`No files found in category ${testFile.category}`);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
const { result, metric } = await PerformanceTracker.track(
|
|
'corpus-parsing',
|
|
async () => {
|
|
const invoice = new einvoice.EInvoice();
|
|
|
|
try {
|
|
await invoice.fromXmlString(xmlContent);
|
|
return {
|
|
success: true,
|
|
format: invoice.getFormat(),
|
|
id: invoice.id,
|
|
hasData: !!invoice.from && !!invoice.to && invoice.items?.length > 0
|
|
};
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: error.message
|
|
};
|
|
}
|
|
}
|
|
);
|
|
|
|
console.log(`${testFile.category}/${testFile.file || 'first-file'}: ${result.success ? '✓' : '✗'}`);
|
|
|
|
if (result.success) {
|
|
console.log(` Format: ${einvoice.InvoiceFormat[result.format]}`);
|
|
console.log(` ID: ${result.id}`);
|
|
console.log(` Has complete data: ${result.hasData}`);
|
|
console.log(` Parse time: ${metric.duration.toFixed(2)}ms`);
|
|
} else {
|
|
console.log(` Error: ${result.error}`);
|
|
}
|
|
} catch (error) {
|
|
console.log(`Failed to load ${testFile.category}/${testFile.file}: ${error.message}`);
|
|
}
|
|
}
|
|
});
|
|
|
|
tap.test('PARSE-01: Error recovery', async () => {
|
|
const errorCases = [
|
|
{
|
|
name: 'Empty XML',
|
|
xml: '',
|
|
expectError: true
|
|
},
|
|
{
|
|
name: 'Invalid XML syntax',
|
|
xml: '<?xml version="1.0"?><invoice><id>TEST</id><invoice>',
|
|
expectError: true
|
|
},
|
|
{
|
|
name: 'Non-invoice XML',
|
|
xml: '<?xml version="1.0"?><root><data>test</data></root>',
|
|
expectError: true
|
|
},
|
|
{
|
|
name: 'Missing mandatory fields',
|
|
xml: `<?xml version="1.0"?>
|
|
<ubl:Invoice xmlns:ubl="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
|
|
<!-- Missing ID and other required fields -->
|
|
</ubl:Invoice>`,
|
|
expectError: true
|
|
}
|
|
];
|
|
|
|
for (const testCase of errorCases) {
|
|
const { result } = await PerformanceTracker.track(
|
|
'error-recovery',
|
|
async () => {
|
|
const invoice = new einvoice.EInvoice();
|
|
|
|
try {
|
|
await invoice.fromXmlString(testCase.xml);
|
|
return { success: true };
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: error.message,
|
|
errorType: error.constructor.name
|
|
};
|
|
}
|
|
}
|
|
);
|
|
|
|
console.log(`${testCase.name}: ${testCase.expectError ? (result.success ? '✗' : '✓') : (result.success ? '✓' : '✗')}`);
|
|
|
|
if (testCase.expectError) {
|
|
expect(result.success).toBeFalse();
|
|
console.log(` Error type: ${result.errorType}`);
|
|
console.log(` Error message: ${result.error}`);
|
|
} else {
|
|
expect(result.success).toBeTrue();
|
|
}
|
|
}
|
|
});
|
|
|
|
tap.test('PARSE-01: Performance summary', async () => {
|
|
const stats = PerformanceTracker.getStats('xml-parsing');
|
|
|
|
if (stats) {
|
|
console.log('\nPerformance Summary:');
|
|
console.log(` Total parses: ${stats.count}`);
|
|
console.log(` Average time: ${stats.avg.toFixed(2)}ms`);
|
|
console.log(` Min time: ${stats.min.toFixed(2)}ms`);
|
|
console.log(` Max time: ${stats.max.toFixed(2)}ms`);
|
|
console.log(` P95 time: ${stats.p95.toFixed(2)}ms`);
|
|
|
|
// Check against thresholds
|
|
expect(stats.avg).toBeLessThan(50); // 50ms average for small files
|
|
expect(stats.p95).toBeLessThan(100); // 100ms for 95th percentile
|
|
}
|
|
});
|
|
|
|
// Run the tests
|
|
tap.start(); |