651 lines
18 KiB
TypeScript
651 lines
18 KiB
TypeScript
import { tap } from '@git.zone/tstest/tapbundle';
|
|
import * as plugins from '../plugins.js';
|
|
import { EInvoice } from '../../../ts/index.js';
|
|
import { PerformanceTracker } from '../performance.tracker.js';
|
|
|
|
const performanceTracker = new PerformanceTracker('EDGE-03: Deeply Nested XML Structures');
|
|
|
|
tap.test('EDGE-03: Deeply Nested XML Structures - should handle extremely nested XML', async (t) => {
|
|
const einvoice = new EInvoice();
|
|
|
|
// Test 1: Linear deep nesting
|
|
const linearDeepNesting = await performanceTracker.measureAsync(
|
|
'linear-deep-nesting',
|
|
async () => {
|
|
const testDepths = [10, 100, 1000, 5000, 10000];
|
|
const results = [];
|
|
|
|
for (const depth of testDepths) {
|
|
let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
|
|
|
|
// Build deeply nested structure
|
|
for (let i = 0; i < depth; i++) {
|
|
xml += ' '.repeat(i) + `<Level${i}>\n`;
|
|
}
|
|
|
|
xml += ' '.repeat(depth) + '<Data>Invoice Data</Data>\n';
|
|
|
|
// Close all tags
|
|
for (let i = depth - 1; i >= 0; i--) {
|
|
xml += ' '.repeat(i) + `</Level${i}>\n`;
|
|
}
|
|
|
|
const startTime = Date.now();
|
|
const startMemory = process.memoryUsage();
|
|
|
|
try {
|
|
const result = await einvoice.parseXML(xml);
|
|
|
|
const endTime = Date.now();
|
|
const endMemory = process.memoryUsage();
|
|
|
|
results.push({
|
|
depth,
|
|
success: true,
|
|
timeTaken: endTime - startTime,
|
|
memoryUsed: endMemory.heapUsed - startMemory.heapUsed,
|
|
hasData: !!result
|
|
});
|
|
} catch (error) {
|
|
results.push({
|
|
depth,
|
|
success: false,
|
|
error: error.message,
|
|
isStackOverflow: error.message.includes('stack') || error.message.includes('depth')
|
|
});
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
);
|
|
|
|
linearDeepNesting.forEach(result => {
|
|
if (result.depth <= 1000) {
|
|
t.ok(result.success, `Depth ${result.depth} should be handled`);
|
|
} else {
|
|
t.ok(!result.success || result.isStackOverflow, `Extreme depth ${result.depth} should be limited`);
|
|
}
|
|
});
|
|
|
|
// Test 2: Recursive element nesting
|
|
const recursiveElementNesting = await performanceTracker.measureAsync(
|
|
'recursive-element-nesting',
|
|
async () => {
|
|
const createRecursiveStructure = (depth: number): string => {
|
|
if (depth === 0) {
|
|
return '<Amount>100.00</Amount>';
|
|
}
|
|
|
|
return `<Item>
|
|
<ID>ITEM-${depth}</ID>
|
|
<SubItems>
|
|
${createRecursiveStructure(depth - 1)}
|
|
</SubItems>
|
|
</Item>`;
|
|
};
|
|
|
|
const testDepths = [5, 10, 20, 50];
|
|
const results = [];
|
|
|
|
for (const depth of testDepths) {
|
|
const xml = `<?xml version="1.0" encoding="UTF-8"?>
|
|
<Invoice>
|
|
<ID>RECURSIVE-001</ID>
|
|
<Items>
|
|
${createRecursiveStructure(depth)}
|
|
</Items>
|
|
</Invoice>`;
|
|
|
|
try {
|
|
const startTime = Date.now();
|
|
const parsed = await einvoice.parseXML(xml);
|
|
const endTime = Date.now();
|
|
|
|
// Count actual depth
|
|
let actualDepth = 0;
|
|
let current = parsed;
|
|
while (current?.Items || current?.SubItems) {
|
|
actualDepth++;
|
|
current = current.Items || current.SubItems;
|
|
}
|
|
|
|
results.push({
|
|
requestedDepth: depth,
|
|
actualDepth,
|
|
success: true,
|
|
timeTaken: endTime - startTime
|
|
});
|
|
} catch (error) {
|
|
results.push({
|
|
requestedDepth: depth,
|
|
success: false,
|
|
error: error.message
|
|
});
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
);
|
|
|
|
recursiveElementNesting.forEach(result => {
|
|
t.ok(result.success || result.error, `Recursive depth ${result.requestedDepth} was processed`);
|
|
});
|
|
|
|
// Test 3: Namespace nesting complexity
|
|
const namespaceNesting = await performanceTracker.measureAsync(
|
|
'namespace-nesting-complexity',
|
|
async () => {
|
|
const createNamespaceNesting = (depth: number): string => {
|
|
let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
|
|
|
|
// Create nested elements with different namespaces
|
|
for (let i = 0; i < depth; i++) {
|
|
xml += ' '.repeat(i) + `<ns${i}:Element xmlns:ns${i}="http://example.com/ns${i}">\n`;
|
|
}
|
|
|
|
xml += ' '.repeat(depth) + '<Data>Content</Data>\n';
|
|
|
|
// Close all namespace elements
|
|
for (let i = depth - 1; i >= 0; i--) {
|
|
xml += ' '.repeat(i) + `</ns${i}:Element>\n`;
|
|
}
|
|
|
|
return xml;
|
|
};
|
|
|
|
const testDepths = [5, 10, 25, 50, 100];
|
|
const results = [];
|
|
|
|
for (const depth of testDepths) {
|
|
const xml = createNamespaceNesting(depth);
|
|
|
|
try {
|
|
const startTime = Date.now();
|
|
const parsed = await einvoice.parseXML(xml);
|
|
const endTime = Date.now();
|
|
|
|
results.push({
|
|
depth,
|
|
success: true,
|
|
timeTaken: endTime - startTime,
|
|
namespacesPreserved: true // Check if namespaces were preserved
|
|
});
|
|
} catch (error) {
|
|
results.push({
|
|
depth,
|
|
success: false,
|
|
error: error.message
|
|
});
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
);
|
|
|
|
namespaceNesting.forEach(result => {
|
|
if (result.depth <= 50) {
|
|
t.ok(result.success, `Namespace depth ${result.depth} should be handled`);
|
|
}
|
|
});
|
|
|
|
// Test 4: Mixed content deep nesting
|
|
const mixedContentNesting = await performanceTracker.measureAsync(
|
|
'mixed-content-deep-nesting',
|
|
async () => {
|
|
const createMixedNesting = (depth: number): string => {
|
|
let xml = '';
|
|
|
|
for (let i = 0; i < depth; i++) {
|
|
xml += `<Level${i}>Text before `;
|
|
}
|
|
|
|
xml += '<Value>Core Value</Value>';
|
|
|
|
for (let i = depth - 1; i >= 0; i--) {
|
|
xml += ` text after</Level${i}>`;
|
|
}
|
|
|
|
return xml;
|
|
};
|
|
|
|
const testCases = [10, 50, 100, 500];
|
|
const results = [];
|
|
|
|
for (const depth of testCases) {
|
|
const xml = `<?xml version="1.0" encoding="UTF-8"?>
|
|
<Invoice>
|
|
<MixedContent>
|
|
${createMixedNesting(depth)}
|
|
</MixedContent>
|
|
</Invoice>`;
|
|
|
|
try {
|
|
const parsed = await einvoice.parseXML(xml);
|
|
|
|
results.push({
|
|
depth,
|
|
success: true,
|
|
hasMixedContent: true
|
|
});
|
|
} catch (error) {
|
|
results.push({
|
|
depth,
|
|
success: false,
|
|
error: error.message
|
|
});
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
);
|
|
|
|
mixedContentNesting.forEach(result => {
|
|
t.ok(result.success || result.error, `Mixed content depth ${result.depth} was handled`);
|
|
});
|
|
|
|
// Test 5: Attribute-heavy deep nesting
|
|
const attributeHeavyNesting = await performanceTracker.measureAsync(
|
|
'attribute-heavy-nesting',
|
|
async () => {
|
|
const createAttributeNesting = (depth: number, attrsPerLevel: number): string => {
|
|
let xml = '';
|
|
|
|
for (let i = 0; i < depth; i++) {
|
|
xml += `<Element${i}`;
|
|
|
|
// Add multiple attributes at each level
|
|
for (let j = 0; j < attrsPerLevel; j++) {
|
|
xml += ` attr${j}="value${i}_${j}"`;
|
|
}
|
|
|
|
xml += '>';
|
|
}
|
|
|
|
xml += 'Content';
|
|
|
|
for (let i = depth - 1; i >= 0; i--) {
|
|
xml += `</Element${i}>`;
|
|
}
|
|
|
|
return xml;
|
|
};
|
|
|
|
const testCases = [
|
|
{ depth: 10, attrs: 10 },
|
|
{ depth: 50, attrs: 5 },
|
|
{ depth: 100, attrs: 3 },
|
|
{ depth: 500, attrs: 1 }
|
|
];
|
|
|
|
const results = [];
|
|
|
|
for (const test of testCases) {
|
|
const xml = `<?xml version="1.0" encoding="UTF-8"?>
|
|
<Invoice>
|
|
${createAttributeNesting(test.depth, test.attrs)}
|
|
</Invoice>`;
|
|
|
|
const startTime = Date.now();
|
|
const startMemory = process.memoryUsage();
|
|
|
|
try {
|
|
await einvoice.parseXML(xml);
|
|
|
|
const endTime = Date.now();
|
|
const endMemory = process.memoryUsage();
|
|
|
|
results.push({
|
|
depth: test.depth,
|
|
attributesPerLevel: test.attrs,
|
|
totalAttributes: test.depth * test.attrs,
|
|
success: true,
|
|
timeTaken: endTime - startTime,
|
|
memoryUsed: endMemory.heapUsed - startMemory.heapUsed
|
|
});
|
|
} catch (error) {
|
|
results.push({
|
|
depth: test.depth,
|
|
attributesPerLevel: test.attrs,
|
|
success: false,
|
|
error: error.message
|
|
});
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
);
|
|
|
|
attributeHeavyNesting.forEach(result => {
|
|
t.ok(result.success || result.error,
|
|
`Attribute-heavy nesting (depth: ${result.depth}, attrs: ${result.attributesPerLevel}) was processed`);
|
|
});
|
|
|
|
// Test 6: CDATA section nesting
|
|
const cdataNesting = await performanceTracker.measureAsync(
|
|
'cdata-section-nesting',
|
|
async () => {
|
|
const depths = [5, 10, 20, 50];
|
|
const results = [];
|
|
|
|
for (const depth of depths) {
|
|
let xml = '<?xml version="1.0" encoding="UTF-8"?><Invoice>';
|
|
|
|
// Create nested elements with CDATA
|
|
for (let i = 0; i < depth; i++) {
|
|
xml += `<Level${i}><![CDATA[Data at level ${i} with <special> characters & symbols]]>`;
|
|
}
|
|
|
|
// Close all elements
|
|
for (let i = depth - 1; i >= 0; i--) {
|
|
xml += `</Level${i}>`;
|
|
}
|
|
|
|
xml += '</Invoice>';
|
|
|
|
try {
|
|
const parsed = await einvoice.parseXML(xml);
|
|
|
|
results.push({
|
|
depth,
|
|
success: true,
|
|
cdataPreserved: true
|
|
});
|
|
} catch (error) {
|
|
results.push({
|
|
depth,
|
|
success: false,
|
|
error: error.message
|
|
});
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
);
|
|
|
|
cdataNesting.forEach(result => {
|
|
t.ok(result.success, `CDATA nesting depth ${result.depth} should be handled`);
|
|
});
|
|
|
|
// Test 7: Processing instruction nesting
|
|
const processingInstructionNesting = await performanceTracker.measureAsync(
|
|
'processing-instruction-nesting',
|
|
async () => {
|
|
const createPINesting = (depth: number): string => {
|
|
let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
|
|
|
|
for (let i = 0; i < depth; i++) {
|
|
xml += `<?process-level-${i} instruction="value"?>\n`;
|
|
xml += `<Level${i}>\n`;
|
|
}
|
|
|
|
xml += '<Data>Content</Data>\n';
|
|
|
|
for (let i = depth - 1; i >= 0; i--) {
|
|
xml += `</Level${i}>\n`;
|
|
}
|
|
|
|
return xml;
|
|
};
|
|
|
|
const depths = [10, 25, 50];
|
|
const results = [];
|
|
|
|
for (const depth of depths) {
|
|
const xml = createPINesting(depth);
|
|
|
|
try {
|
|
const parsed = await einvoice.parseXML(xml);
|
|
|
|
results.push({
|
|
depth,
|
|
success: true,
|
|
processingInstructionsHandled: true
|
|
});
|
|
} catch (error) {
|
|
results.push({
|
|
depth,
|
|
success: false,
|
|
error: error.message
|
|
});
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
);
|
|
|
|
processingInstructionNesting.forEach(result => {
|
|
t.ok(result.success, `PI nesting depth ${result.depth} should be handled`);
|
|
});
|
|
|
|
// Test 8: Real invoice format deep structures
|
|
const realFormatDeepStructures = await performanceTracker.measureAsync(
|
|
'real-format-deep-structures',
|
|
async () => {
|
|
const formats = ['ubl', 'cii'];
|
|
const results = [];
|
|
|
|
for (const format of formats) {
|
|
// Create deeply nested invoice structure
|
|
let invoice;
|
|
|
|
if (format === 'ubl') {
|
|
invoice = `<?xml version="1.0" encoding="UTF-8"?>
|
|
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
|
|
<ID>DEEP-UBL-001</ID>
|
|
<Note>
|
|
<SubNote>
|
|
<SubSubNote>
|
|
<Content>
|
|
<Detail>
|
|
<SubDetail>
|
|
<Information>Deeply nested note</Information>
|
|
</SubDetail>
|
|
</Detail>
|
|
</Content>
|
|
</SubSubNote>
|
|
</SubNote>
|
|
</Note>
|
|
<InvoiceLine>
|
|
<Item>
|
|
<AdditionalItemProperty>
|
|
<Value>
|
|
<SubValue>
|
|
<Detail>
|
|
<SubDetail>
|
|
<Information>Deep item property</Information>
|
|
</SubDetail>
|
|
</Detail>
|
|
</SubValue>
|
|
</Value>
|
|
</AdditionalItemProperty>
|
|
</Item>
|
|
</InvoiceLine>
|
|
</Invoice>`;
|
|
} else {
|
|
invoice = `<?xml version="1.0" encoding="UTF-8"?>
|
|
<rsm:CrossIndustryInvoice xmlns:rsm="urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100">
|
|
<rsm:ExchangedDocument>
|
|
<ram:ID>DEEP-CII-001</ram:ID>
|
|
<ram:IncludedNote>
|
|
<ram:Content>
|
|
<ram:SubContent>
|
|
<ram:Detail>
|
|
<ram:SubDetail>
|
|
<ram:Information>Deep CII structure</ram:Information>
|
|
</ram:SubDetail>
|
|
</ram:Detail>
|
|
</ram:SubContent>
|
|
</ram:Content>
|
|
</ram:IncludedNote>
|
|
</rsm:ExchangedDocument>
|
|
</rsm:CrossIndustryInvoice>`;
|
|
}
|
|
|
|
try {
|
|
const parsed = await einvoice.parseDocument(invoice);
|
|
const validated = await einvoice.validate(parsed);
|
|
|
|
results.push({
|
|
format,
|
|
parsed: true,
|
|
valid: validated?.isValid || false,
|
|
deepStructureSupported: true
|
|
});
|
|
} catch (error) {
|
|
results.push({
|
|
format,
|
|
parsed: false,
|
|
error: error.message
|
|
});
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
);
|
|
|
|
realFormatDeepStructures.forEach(result => {
|
|
t.ok(result.parsed, `${result.format} deep structure should be parsed`);
|
|
});
|
|
|
|
// Test 9: Stack overflow protection
|
|
const stackOverflowProtection = await performanceTracker.measureAsync(
|
|
'stack-overflow-protection',
|
|
async () => {
|
|
const extremeDepths = [10000, 50000, 100000];
|
|
const results = [];
|
|
|
|
for (const depth of extremeDepths) {
|
|
// Create extremely deep structure efficiently
|
|
const parts = [];
|
|
parts.push('<?xml version="1.0" encoding="UTF-8"?>');
|
|
|
|
// Opening tags
|
|
for (let i = 0; i < Math.min(depth, 1000); i++) {
|
|
parts.push(`<L${i}>`);
|
|
}
|
|
|
|
parts.push('<Data>Test</Data>');
|
|
|
|
// Closing tags
|
|
for (let i = Math.min(depth - 1, 999); i >= 0; i--) {
|
|
parts.push(`</L${i}>`);
|
|
}
|
|
|
|
const xml = parts.join('');
|
|
|
|
const startTime = Date.now();
|
|
|
|
try {
|
|
await einvoice.parseXML(xml, { maxDepth: 1000 });
|
|
|
|
const endTime = Date.now();
|
|
|
|
results.push({
|
|
depth,
|
|
protected: true,
|
|
method: 'depth-limit',
|
|
timeTaken: endTime - startTime
|
|
});
|
|
} catch (error) {
|
|
const endTime = Date.now();
|
|
|
|
results.push({
|
|
depth,
|
|
protected: true,
|
|
method: error.message.includes('depth') ? 'depth-check' : 'stack-guard',
|
|
timeTaken: endTime - startTime,
|
|
error: error.message
|
|
});
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
);
|
|
|
|
stackOverflowProtection.forEach(result => {
|
|
t.ok(result.protected, `Stack overflow protection active for depth ${result.depth}`);
|
|
});
|
|
|
|
// Test 10: Performance impact of nesting
|
|
const nestingPerformanceImpact = await performanceTracker.measureAsync(
|
|
'nesting-performance-impact',
|
|
async () => {
|
|
const depths = [1, 10, 50, 100, 500, 1000];
|
|
const results = [];
|
|
|
|
for (const depth of depths) {
|
|
// Create invoice with specific nesting depth
|
|
let xml = '<?xml version="1.0" encoding="UTF-8"?><Invoice>';
|
|
|
|
// Create structure at depth
|
|
let current = xml;
|
|
for (let i = 0; i < depth; i++) {
|
|
current += `<Item${i}>`;
|
|
}
|
|
|
|
current += '<ID>TEST</ID><Amount>100</Amount>';
|
|
|
|
for (let i = depth - 1; i >= 0; i--) {
|
|
current += `</Item${i}>`;
|
|
}
|
|
|
|
current += '</Invoice>';
|
|
|
|
// Measure parsing time
|
|
const iterations = 10;
|
|
const times = [];
|
|
|
|
for (let i = 0; i < iterations; i++) {
|
|
const startTime = process.hrtime.bigint();
|
|
|
|
try {
|
|
await einvoice.parseXML(current);
|
|
} catch (error) {
|
|
// Ignore errors for performance testing
|
|
}
|
|
|
|
const endTime = process.hrtime.bigint();
|
|
times.push(Number(endTime - startTime) / 1000000); // Convert to ms
|
|
}
|
|
|
|
const avgTime = times.reduce((a, b) => a + b, 0) / times.length;
|
|
const minTime = Math.min(...times);
|
|
const maxTime = Math.max(...times);
|
|
|
|
results.push({
|
|
depth,
|
|
avgTime,
|
|
minTime,
|
|
maxTime,
|
|
complexity: avgTime / depth // Time per nesting level
|
|
});
|
|
}
|
|
|
|
return results;
|
|
}
|
|
);
|
|
|
|
// Verify performance doesn't degrade exponentially
|
|
const complexities = nestingPerformanceImpact.map(r => r.complexity);
|
|
const avgComplexity = complexities.reduce((a, b) => a + b, 0) / complexities.length;
|
|
|
|
nestingPerformanceImpact.forEach(result => {
|
|
t.ok(result.complexity < avgComplexity * 10,
|
|
`Nesting depth ${result.depth} has reasonable performance`);
|
|
});
|
|
|
|
// Print performance summary
|
|
performanceTracker.printSummary();
|
|
});
|
|
|
|
// Run the test
|
|
tap.start(); |