497 lines
18 KiB
TypeScript
497 lines
18 KiB
TypeScript
/**
|
|
* @file test.conv-12.performance.ts
|
|
* @description Performance benchmarks for format conversion operations
|
|
*/
|
|
|
|
import { expect, tap } from '@git.zone/tstest/tapbundle';
|
|
import * as plugins from '../../plugins.js';
|
|
import { EInvoice } from '../../../ts/index.js';
|
|
|
|
tap.test('CONV-12: Performance - should measure single XML load/export performance', async () => {
|
|
const einvoice = new EInvoice();
|
|
const benchmarks = [];
|
|
|
|
// Define test scenarios
|
|
const scenarios = [
|
|
{ format: 'ubl', name: 'UBL Load/Export' },
|
|
{ format: 'cii', name: 'CII Load/Export' }
|
|
];
|
|
|
|
// Create test invoices for each format
|
|
const testInvoices = {
|
|
ubl: `<?xml version="1.0" encoding="UTF-8"?>
|
|
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2"
|
|
xmlns:cac="urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2"
|
|
xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2">
|
|
<cbc:ID>PERF-UBL-001</cbc:ID>
|
|
<cbc:IssueDate>2024-01-30</cbc:IssueDate>
|
|
<cbc:InvoiceTypeCode>380</cbc:InvoiceTypeCode>
|
|
<cbc:DocumentCurrencyCode>EUR</cbc:DocumentCurrencyCode>
|
|
<cac:AccountingSupplierParty>
|
|
<cac:Party>
|
|
<cac:PartyName>
|
|
<cbc:Name>UBL Performance Test Seller</cbc:Name>
|
|
</cac:PartyName>
|
|
</cac:Party>
|
|
</cac:AccountingSupplierParty>
|
|
<cac:AccountingCustomerParty>
|
|
<cac:Party>
|
|
<cac:PartyName>
|
|
<cbc:Name>UBL Performance Test Buyer</cbc:Name>
|
|
</cac:PartyName>
|
|
</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>Product</cbc:Name>
|
|
</cac:Item>
|
|
<cac:Price>
|
|
<cbc:PriceAmount currencyID="EUR">100.00</cbc:PriceAmount>
|
|
</cac:Price>
|
|
</cac:InvoiceLine>
|
|
<cac:LegalMonetaryTotal>
|
|
<cbc:PayableAmount currencyID="EUR">110.00</cbc:PayableAmount>
|
|
</cac:LegalMonetaryTotal>
|
|
</Invoice>`,
|
|
cii: `<?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:ExchangedDocument>
|
|
<ram:ID>PERF-CII-001</ram:ID>
|
|
<ram:TypeCode>380</ram:TypeCode>
|
|
<ram:IssueDateTime>
|
|
<udt:DateTimeString format="102">20240130</udt:DateTimeString>
|
|
</ram:IssueDateTime>
|
|
</rsm:ExchangedDocument>
|
|
<rsm:SupplyChainTradeTransaction>
|
|
<ram:ApplicableHeaderTradeAgreement>
|
|
<ram:SellerTradeParty>
|
|
<ram:Name>CII Performance Test Seller</ram:Name>
|
|
</ram:SellerTradeParty>
|
|
<ram:BuyerTradeParty>
|
|
<ram:Name>CII Performance Test Buyer</ram:Name>
|
|
</ram:BuyerTradeParty>
|
|
</ram:ApplicableHeaderTradeAgreement>
|
|
<ram:ApplicableHeaderTradeSettlement>
|
|
<ram:InvoiceCurrencyCode>EUR</ram:InvoiceCurrencyCode>
|
|
<ram:SpecifiedTradeSettlementHeaderMonetarySummation>
|
|
<ram:GrandTotalAmount>238.00</ram:GrandTotalAmount>
|
|
</ram:SpecifiedTradeSettlementHeaderMonetarySummation>
|
|
</ram:ApplicableHeaderTradeSettlement>
|
|
</rsm:SupplyChainTradeTransaction>
|
|
</rsm:CrossIndustryInvoice>`
|
|
};
|
|
|
|
// Run benchmarks
|
|
for (const scenario of scenarios) {
|
|
const iterations = 10;
|
|
const times = [];
|
|
|
|
for (let i = 0; i < iterations; i++) {
|
|
const startTime = process.hrtime.bigint();
|
|
|
|
try {
|
|
// Load XML
|
|
await einvoice.loadXml(testInvoices[scenario.format]);
|
|
|
|
// Export back to XML
|
|
await einvoice.toXmlString(scenario.format as any);
|
|
|
|
const endTime = process.hrtime.bigint();
|
|
const duration = Number(endTime - startTime) / 1_000_000; // Convert to milliseconds
|
|
times.push(duration);
|
|
} catch (error) {
|
|
console.log(`Error in ${scenario.name}:`, error);
|
|
}
|
|
}
|
|
|
|
if (times.length > 0) {
|
|
times.sort((a, b) => a - b);
|
|
benchmarks.push({
|
|
scenario: scenario.name,
|
|
min: times[0],
|
|
max: times[times.length - 1],
|
|
avg: times.reduce((a, b) => a + b, 0) / times.length,
|
|
median: times[Math.floor(times.length / 2)],
|
|
p95: times[Math.floor(times.length * 0.95)] || times[times.length - 1]
|
|
});
|
|
}
|
|
}
|
|
|
|
console.log('\nSingle Operation Benchmarks (10 iterations each):');
|
|
benchmarks.forEach(bench => {
|
|
console.log(` ${bench.scenario}:`);
|
|
console.log(` - Min: ${bench.min.toFixed(2)}ms, Max: ${bench.max.toFixed(2)}ms`);
|
|
console.log(` - Average: ${bench.avg.toFixed(2)}ms, Median: ${bench.median.toFixed(2)}ms, P95: ${bench.p95.toFixed(2)}ms`);
|
|
});
|
|
|
|
expect(benchmarks.length).toBeGreaterThan(0);
|
|
benchmarks.forEach(bench => {
|
|
expect(bench.avg).toBeLessThan(100); // Should process in less than 100ms on average
|
|
});
|
|
});
|
|
|
|
tap.test('CONV-12: Performance - should handle complex invoice with many items', async () => {
|
|
const einvoice = new EInvoice();
|
|
|
|
// Create complex invoice with many items
|
|
const itemCount = 100;
|
|
const complexInvoice = `<?xml version="1.0" encoding="UTF-8"?>
|
|
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2"
|
|
xmlns:cac="urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2"
|
|
xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2">
|
|
<cbc:ID>PERF-COMPLEX-001</cbc:ID>
|
|
<cbc:IssueDate>2024-01-30</cbc:IssueDate>
|
|
<cbc:DueDate>2024-02-29</cbc:DueDate>
|
|
<cbc:InvoiceTypeCode>380</cbc:InvoiceTypeCode>
|
|
<cbc:DocumentCurrencyCode>EUR</cbc:DocumentCurrencyCode>
|
|
<cbc:Note>This is a complex invoice with ${itemCount} line items for performance testing purposes.</cbc:Note>
|
|
<cac:AccountingSupplierParty>
|
|
<cac:Party>
|
|
<cac:PartyName>
|
|
<cbc:Name>Complex International Trading Company Ltd.</cbc:Name>
|
|
</cac:PartyName>
|
|
<cac:PostalAddress>
|
|
<cbc:StreetName>Global Business Center, Tower A, Floor 25</cbc:StreetName>
|
|
<cbc:CityName>London</cbc:CityName>
|
|
<cbc:PostalZone>EC2M 7PY</cbc:PostalZone>
|
|
<cac:Country>
|
|
<cbc:IdentificationCode>GB</cbc:IdentificationCode>
|
|
</cac:Country>
|
|
</cac:PostalAddress>
|
|
<cac:PartyTaxScheme>
|
|
<cbc:CompanyID>GB123456789</cbc:CompanyID>
|
|
<cac:TaxScheme>
|
|
<cbc:ID>VAT</cbc:ID>
|
|
</cac:TaxScheme>
|
|
</cac:PartyTaxScheme>
|
|
</cac:Party>
|
|
</cac:AccountingSupplierParty>
|
|
<cac:AccountingCustomerParty>
|
|
<cac:Party>
|
|
<cac:PartyName>
|
|
<cbc:Name>Multinational Buyer Corporation GmbH</cbc:Name>
|
|
</cac:PartyName>
|
|
<cac:PostalAddress>
|
|
<cbc:StreetName>Industriestraße 100-200</cbc:StreetName>
|
|
<cbc:CityName>Frankfurt</cbc:CityName>
|
|
<cbc:PostalZone>60311</cbc:PostalZone>
|
|
<cac:Country>
|
|
<cbc:IdentificationCode>DE</cbc:IdentificationCode>
|
|
</cac:Country>
|
|
</cac:PostalAddress>
|
|
</cac:Party>
|
|
</cac:AccountingCustomerParty>
|
|
${Array.from({ length: itemCount }, (_, i) => `
|
|
<cac:InvoiceLine>
|
|
<cbc:ID>${i + 1}</cbc:ID>
|
|
<cbc:InvoicedQuantity unitCode="EA">${Math.floor(Math.random() * 100) + 1}</cbc:InvoicedQuantity>
|
|
<cbc:LineExtensionAmount currencyID="EUR">${(Math.random() * 1000).toFixed(2)}</cbc:LineExtensionAmount>
|
|
<cac:Item>
|
|
<cbc:Name>Product Line Item ${i + 1} - Detailed description with technical specifications</cbc:Name>
|
|
</cac:Item>
|
|
<cac:Price>
|
|
<cbc:PriceAmount currencyID="EUR">${(Math.random() * 100).toFixed(2)}</cbc:PriceAmount>
|
|
</cac:Price>
|
|
</cac:InvoiceLine>`).join('')}
|
|
<cac:LegalMonetaryTotal>
|
|
<cbc:LineExtensionAmount currencyID="EUR">50000.00</cbc:LineExtensionAmount>
|
|
<cbc:TaxExclusiveAmount currencyID="EUR">50000.00</cbc:TaxExclusiveAmount>
|
|
<cbc:TaxInclusiveAmount currencyID="EUR">59500.00</cbc:TaxInclusiveAmount>
|
|
<cbc:PayableAmount currencyID="EUR">59500.00</cbc:PayableAmount>
|
|
</cac:LegalMonetaryTotal>
|
|
</Invoice>`;
|
|
|
|
const results = [];
|
|
const operations = ['load', 'export'];
|
|
|
|
for (const operation of operations) {
|
|
const startTime = process.hrtime.bigint();
|
|
let success = false;
|
|
|
|
try {
|
|
if (operation === 'load') {
|
|
await einvoice.loadXml(complexInvoice);
|
|
success = einvoice.id === 'PERF-COMPLEX-001';
|
|
} else {
|
|
const exported = await einvoice.toXmlString('ubl');
|
|
success = exported.includes('PERF-COMPLEX-001');
|
|
}
|
|
} catch (e) {
|
|
console.log(`Error in ${operation}:`, e);
|
|
}
|
|
|
|
const endTime = process.hrtime.bigint();
|
|
const duration = Number(endTime - startTime) / 1_000_000;
|
|
|
|
results.push({
|
|
operation,
|
|
duration,
|
|
success,
|
|
itemsPerSecond: success ? (itemCount / (duration / 1000)).toFixed(2) : 'N/A'
|
|
});
|
|
}
|
|
|
|
console.log('\nComplex Invoice Performance (100 items):');
|
|
results.forEach(result => {
|
|
console.log(` ${result.operation}: ${result.duration.toFixed(2)}ms (${result.itemsPerSecond} items/sec) - ${result.success ? 'SUCCESS' : 'FAILED'}`);
|
|
});
|
|
|
|
expect(results.filter(r => r.success).length).toBeGreaterThan(0);
|
|
});
|
|
|
|
tap.test('CONV-12: Performance - should analyze memory usage during operations', async () => {
|
|
const memorySnapshots = [];
|
|
|
|
// Force garbage collection if available
|
|
if (global.gc) global.gc();
|
|
const baselineMemory = process.memoryUsage();
|
|
|
|
// Create invoices of increasing size
|
|
const sizes = [1, 10, 50, 100];
|
|
|
|
for (const size of sizes) {
|
|
const einvoice = new EInvoice();
|
|
const invoice = `<?xml version="1.0" encoding="UTF-8"?>
|
|
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2"
|
|
xmlns:cac="urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2"
|
|
xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2">
|
|
<cbc:ID>MEM-TEST-${size}</cbc:ID>
|
|
<cbc:IssueDate>2024-01-30</cbc:IssueDate>
|
|
<cbc:InvoiceTypeCode>380</cbc:InvoiceTypeCode>
|
|
<cbc:DocumentCurrencyCode>EUR</cbc:DocumentCurrencyCode>
|
|
<cac:AccountingSupplierParty>
|
|
<cac:Party>
|
|
<cac:PartyName>
|
|
<cbc:Name>Memory Test Seller</cbc:Name>
|
|
</cac:PartyName>
|
|
</cac:Party>
|
|
</cac:AccountingSupplierParty>
|
|
<cac:AccountingCustomerParty>
|
|
<cac:Party>
|
|
<cac:PartyName>
|
|
<cbc:Name>Memory Test Buyer</cbc:Name>
|
|
</cac:PartyName>
|
|
</cac:Party>
|
|
</cac:AccountingCustomerParty>
|
|
${Array.from({ length: size }, (_, i) => `
|
|
<cac:InvoiceLine>
|
|
<cbc:ID>${i + 1}</cbc:ID>
|
|
<cbc:InvoicedQuantity unitCode="EA">1</cbc:InvoicedQuantity>
|
|
<cbc:LineExtensionAmount currencyID="EUR">100.00</cbc:LineExtensionAmount>
|
|
<cac:Item>
|
|
<cbc:Name>Item ${i + 1} with a reasonably long description to simulate real-world data</cbc:Name>
|
|
</cac:Item>
|
|
<cac:Price>
|
|
<cbc:PriceAmount currencyID="EUR">100.00</cbc:PriceAmount>
|
|
</cac:Price>
|
|
</cac:InvoiceLine>`).join('')}
|
|
<cac:LegalMonetaryTotal>
|
|
<cbc:PayableAmount currencyID="EUR">${size * 110}.00</cbc:PayableAmount>
|
|
</cac:LegalMonetaryTotal>
|
|
</Invoice>`;
|
|
|
|
// Measure memory before and after operations
|
|
const beforeOperation = process.memoryUsage();
|
|
|
|
try {
|
|
await einvoice.loadXml(invoice);
|
|
await einvoice.toXmlString('ubl');
|
|
|
|
const afterOperation = process.memoryUsage();
|
|
|
|
memorySnapshots.push({
|
|
items: size,
|
|
heapUsedBefore: Math.round((beforeOperation.heapUsed - baselineMemory.heapUsed) / 1024 / 1024 * 100) / 100,
|
|
heapUsedAfter: Math.round((afterOperation.heapUsed - baselineMemory.heapUsed) / 1024 / 1024 * 100) / 100,
|
|
heapIncrease: Math.round((afterOperation.heapUsed - beforeOperation.heapUsed) / 1024 / 1024 * 100) / 100,
|
|
external: Math.round((afterOperation.external - baselineMemory.external) / 1024 / 1024 * 100) / 100
|
|
});
|
|
} catch (error) {
|
|
// Skip if operation fails
|
|
}
|
|
}
|
|
|
|
// Force garbage collection and measure final state
|
|
if (global.gc) global.gc();
|
|
const finalMemory = process.memoryUsage();
|
|
|
|
const totalMemoryIncrease = Math.round((finalMemory.heapUsed - baselineMemory.heapUsed) / 1024 / 1024 * 100) / 100;
|
|
const memoryPerItem = memorySnapshots.length > 0 ?
|
|
(memorySnapshots[memorySnapshots.length - 1].heapIncrease / sizes[sizes.length - 1]).toFixed(3) : 'N/A';
|
|
|
|
console.log('\nMemory Usage Analysis:');
|
|
memorySnapshots.forEach(snap => {
|
|
console.log(` ${snap.items} items: ${snap.heapIncrease}MB heap increase`);
|
|
});
|
|
console.log(` Total memory increase: ${totalMemoryIncrease}MB`);
|
|
console.log(` Average memory per item: ${memoryPerItem}MB`);
|
|
|
|
expect(memorySnapshots.length).toBeGreaterThan(0);
|
|
// Memory increase should be reasonable
|
|
expect(totalMemoryIncrease).toBeLessThan(50);
|
|
});
|
|
|
|
tap.test('CONV-12: Performance - should handle concurrent operations', async () => {
|
|
const concurrencyLevels = [1, 5, 10];
|
|
const results = [];
|
|
|
|
// Create test invoice
|
|
const testInvoice = `<?xml version="1.0" encoding="UTF-8"?>
|
|
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2"
|
|
xmlns:cac="urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2"
|
|
xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2">
|
|
<cbc:ID>CONC-TEST-001</cbc:ID>
|
|
<cbc:IssueDate>2024-01-30</cbc:IssueDate>
|
|
<cbc:InvoiceTypeCode>380</cbc:InvoiceTypeCode>
|
|
<cbc:DocumentCurrencyCode>EUR</cbc:DocumentCurrencyCode>
|
|
<cac:AccountingSupplierParty>
|
|
<cac:Party>
|
|
<cac:PartyName>
|
|
<cbc:Name>Concurrent Seller</cbc:Name>
|
|
</cac:PartyName>
|
|
</cac:Party>
|
|
</cac:AccountingSupplierParty>
|
|
<cac:AccountingCustomerParty>
|
|
<cac:Party>
|
|
<cac:PartyName>
|
|
<cbc:Name>Concurrent Buyer</cbc:Name>
|
|
</cac:PartyName>
|
|
</cac:Party>
|
|
</cac:AccountingCustomerParty>
|
|
<cac:LegalMonetaryTotal>
|
|
<cbc:PayableAmount currencyID="EUR">1100.00</cbc:PayableAmount>
|
|
</cac:LegalMonetaryTotal>
|
|
</Invoice>`;
|
|
|
|
for (const concurrency of concurrencyLevels) {
|
|
const startTime = Date.now();
|
|
|
|
// Create concurrent load/export tasks
|
|
const tasks = Array.from({ length: concurrency }, async () => {
|
|
try {
|
|
const einvoice = new EInvoice();
|
|
await einvoice.loadXml(testInvoice);
|
|
await einvoice.toXmlString('ubl');
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
});
|
|
|
|
const taskResults = await Promise.all(tasks);
|
|
const endTime = Date.now();
|
|
|
|
const successful = taskResults.filter(r => r).length;
|
|
const duration = endTime - startTime;
|
|
const throughput = (successful / (duration / 1000)).toFixed(2);
|
|
|
|
results.push({
|
|
concurrency,
|
|
duration,
|
|
successful,
|
|
failed: concurrency - successful,
|
|
throughput: `${throughput} operations/sec`
|
|
});
|
|
}
|
|
|
|
console.log('\nConcurrent Operations Performance:');
|
|
results.forEach(result => {
|
|
console.log(` ${result.concurrency} concurrent: ${result.duration}ms total, ${result.throughput}`);
|
|
});
|
|
|
|
expect(results.every(r => r.successful > 0)).toEqual(true);
|
|
});
|
|
|
|
tap.test('CONV-12: Performance - should analyze corpus file processing performance', async () => {
|
|
const corpusDir = plugins.path.join(process.cwd(), 'test/assets/corpus');
|
|
const performanceData = {
|
|
totalFiles: 0,
|
|
successfulLoads: 0,
|
|
processingTimes: [] as number[],
|
|
sizeCategories: {
|
|
small: { count: 0, avgTime: 0, totalTime: 0 }, // < 10KB
|
|
medium: { count: 0, avgTime: 0, totalTime: 0 }, // 10KB - 100KB
|
|
large: { count: 0, avgTime: 0, totalTime: 0 } // > 100KB
|
|
}
|
|
};
|
|
|
|
// Sample a few known corpus files
|
|
const testFiles = [
|
|
'XML-Rechnung/UBL/EN16931_Einfach.ubl.xml',
|
|
'XML-Rechnung/CII/EN16931_Einfach.cii.xml',
|
|
'XML-Rechnung/UBL/EN16931_Rabatte.ubl.xml',
|
|
'XML-Rechnung/CII/EN16931_Rabatte.cii.xml',
|
|
'PEPPOL/Valid/billing-3.0-invoice-full-sample.xml'
|
|
];
|
|
|
|
for (const file of testFiles) {
|
|
const fullPath = plugins.path.join(corpusDir, file);
|
|
try {
|
|
const content = await plugins.fs.readFile(fullPath, 'utf-8');
|
|
const fileSize = Buffer.byteLength(content, 'utf-8');
|
|
performanceData.totalFiles++;
|
|
|
|
// Categorize by size
|
|
const sizeCategory = fileSize < 10240 ? 'small' :
|
|
fileSize < 102400 ? 'medium' : 'large';
|
|
|
|
// Measure load time
|
|
const startTime = process.hrtime.bigint();
|
|
|
|
try {
|
|
const einvoice = new EInvoice();
|
|
await einvoice.loadXml(content);
|
|
|
|
const endTime = process.hrtime.bigint();
|
|
const duration = Number(endTime - startTime) / 1_000_000;
|
|
|
|
if (einvoice.id) {
|
|
performanceData.successfulLoads++;
|
|
performanceData.processingTimes.push(duration);
|
|
|
|
// Update size category stats
|
|
performanceData.sizeCategories[sizeCategory].count++;
|
|
performanceData.sizeCategories[sizeCategory].totalTime += duration;
|
|
}
|
|
} catch (error) {
|
|
// Skip files that can't be loaded
|
|
}
|
|
} catch (error) {
|
|
// File doesn't exist
|
|
}
|
|
}
|
|
|
|
// Calculate averages
|
|
for (const category of Object.keys(performanceData.sizeCategories)) {
|
|
const cat = performanceData.sizeCategories[category];
|
|
if (cat.count > 0) {
|
|
cat.avgTime = cat.totalTime / cat.count;
|
|
}
|
|
}
|
|
|
|
const avgProcessingTime = performanceData.processingTimes.length > 0 ?
|
|
performanceData.processingTimes.reduce((a, b) => a + b, 0) / performanceData.processingTimes.length : 0;
|
|
|
|
console.log('\nCorpus File Processing Performance:');
|
|
console.log(` Files tested: ${performanceData.totalFiles}`);
|
|
console.log(` Successfully loaded: ${performanceData.successfulLoads}`);
|
|
console.log(` Average processing time: ${avgProcessingTime.toFixed(2)}ms`);
|
|
console.log(' By size:');
|
|
Object.entries(performanceData.sizeCategories).forEach(([size, data]) => {
|
|
if (data.count > 0) {
|
|
console.log(` - ${size}: ${data.count} files, avg ${data.avgTime.toFixed(2)}ms`);
|
|
}
|
|
});
|
|
|
|
expect(performanceData.successfulLoads).toBeGreaterThan(0);
|
|
// Average processing time should be reasonable
|
|
expect(avgProcessingTime).toBeLessThan(500);
|
|
});
|
|
|
|
tap.start();
|