bjkim1/SPipe
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
SPipe/tests/regression.test.ts
T
bjkim1 14f07181db 예전 프로그램 이름 표기 정리: 실행 파일 이름을 start-spipe.bat, stop-spipe.bat로 변경 
- README, 예제 설명, 코드 주석, CSS 머리말, 시험 임시 폴더 접두어의 예전 이름 정리
- 브라우저 저장 키·세션 DB 이름은 저장된 설정 보존을 위해 유지
2026-10-30 11:07:14 +09:00

3934 lines
154 KiB
TypeScript
Raw Permalink Blame History

import assert from 'node:assert/strict';
import test from 'node:test';
import fs from 'node:fs';
import path from 'node:path';
import os from 'node:os';
import { fileURLToPath } from 'node:url';
import { execSync as execSyncRaw, type ExecSyncOptions } from 'node:child_process';
// Resolve everything from the repo root, not the caller's cwd: the suite used
// relative paths ('.venv/...', 'public/...') and 9 DLL tests failed when run
// from any other directory (TEST-1).
const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
process.chdir(REPO_ROOT);
// node:test's per-test timeout cannot interrupt a synchronous child process,
// so a stuck venv launcher ("Unable to create process using ...") hung the
// whole run indefinitely (TEST-2). Every shell-out gets a hard timeout.
const EXEC_TIMEOUT_MS = 120_000;
function execSync(command: string, options: ExecSyncOptions = {}): any {
return execSyncRaw(command, { timeout: EXEC_TIMEOUT_MS, windowsHide: true, ...options });
}
import {
parseInp,
generateInp,
updatePattern,
updateControl,
deleteNode,
splitPipe,
validateTopology,
findPathToNearestSource,
renameNode,
renamePipe,
updateNodeAttributes,
updatePipeAttributes,
updatePumpAttributes,
updateValveAttributes,
convertPipeToValve,
reversePipeDirection,
updateOptions,
} from '../src/inpModel.ts';
import { UNIT_FIELD_KINDS, validateSingleField } from '../src/attributeTableValidation.ts';
import { computeComparison, DEFAULT_TOLERANCES } from '../src/comparisonEngine.ts';
import { inspectConvergence, extractEngineIssues } from '../src/convergence.ts';
import {
computeIsStale,
computeScenarioMetrics,
deriveBaseScenarioResult,
evaluateFilterCondition,
formatTimeLabel,
resolveDualEngineOutcome,
rowMatchesAllConditions,
saveActiveScenarioState,
seriesValue,
type FilterCondition,
} from '../src/resultSync.ts';
import {
calculateGeoAwareDistance,
haversineMeters,
modelToLngLat,
lngLatToModel,
SUPPORTED_CRS_DEFINITIONS,
type CRS,
} from '../src/crs.ts';
import {
buildNetworkFromGeoJSON,
autoDetectFields,
inferRoughnessFromMaterial,
} from '../src/gisImport.ts';
import {
parseGeoJsonString,
computeGeoJsonExtents,
normalizeGeoJsonToWgs84,
unzipArchive,
parseDbfBinary,
parseShpBinary,
} from '../src/gisLayers.ts';
import { exportNetworkShapefileZip } from '../src/shapefileExport.ts';
import {
createNetworkClipboardPayload,
validateAndPreparePaste,
applyPasteToModel,
} from '../src/networkClipboard.ts';
import type { SimulationResult } from '../src/types.ts';
import type { Scenario } from '../src/types.ts';
import {
computeUnitHeadloss,
diameterToMillimeters,
flowToM3Day,
getDisplayUnits,
lengthToMeters,
m3DayToFlow,
metersToLength,
metersToPressure,
millimetersToDiameter,
pressureToMeters,
resolveNativeThresholds,
resolvePressureUnit,
} from '../src/unitSystem.ts';
import { normalizeStoredSnapshot } from '../src/sessionStore.ts';
import { decodeInpBytes } from '../src/inpEncoding.ts';
import { selectNetworkFeaturesInBox } from '../src/mapSelection.ts';
import { formatMapServiceError, MapServiceError } from '../src/mapServices.ts';
test('1. PATTERNS: should preserve high-precision multipliers and avoid appending duplicate original rows', () => {
const sampleInp = `[TITLE]
Pattern Test
[JUNCTIONS]
J1 10 10 1 ;
[RESERVOIRS]
R1 50 ;
[PIPES]
P1 R1 J1 100 200 100 0 Open ;
[PATTERNS]
;ID Multipliers
1 1.234567 0.987654 1.555555
1 0.444444 1.111111 0.777777
[COORDINATES]
J1 10 10
R1 0 0
[END]
`;
const model = parseInp(sampleInp);
assert.ok(model.patterns['1'], 'Pattern 1 should be parsed');
// Check precision preservation
assert.equal(
model.patterns['1'].multipliers[0],
1.234567,
'Multiplier precision should be preserved, not truncated by toFixed(2)'
);
// Update pattern
const updated = updatePattern(model, '1', [2.123456, 1.987654]);
const regen = generateInp(updated);
// Check that original lines were not duplicated or appended
const linesWithPattern1 = regen
.split(/\r?\n/)
.filter((l) => l.trim().startsWith('1') && !l.includes('['));
// Should have only lines representing the updated multipliers, not the old ones
const joinedText = linesWithPattern1.join(' ');
assert.ok(
joinedText.includes('2.123456'),
'Should contain updated high-precision multiplier'
);
assert.ok(
!joinedText.includes('1.234567'),
'Should NOT contain old multiplier after update'
);
assert.ok(
!joinedText.includes('0.444444'),
'Should NOT contain old second row multiplier after update'
);
});
test('2. OPTIONS: should preserve Demand Model (PDA) and Demand Multiplier without key collision', () => {
const sampleInp = `[TITLE]
Options Collision Test
[OPTIONS]
Units LPS
Headloss H-W
Demand Model PDA
Demand Multiplier 1.25
Minimum Pressure 2.5
Required Pressure 15.0
Pressure Exponent 0.5
Accuracy 0.0005
Trials 50
[JUNCTIONS]
J1 10 10 ;
[RESERVOIRS]
R1 50 ;
[PIPES]
P1 R1 J1 100 200 100 0 Open ;
[COORDINATES]
J1 10 10
R1 0 0
[END]
`;
const model = parseInp(sampleInp);
const regen = generateInp(model);
// Demand Model PDA and Demand Multiplier 1.25 must both be present
assert.ok(
/Demand\s+Model\s+PDA/i.test(regen),
'Demand Model PDA must be preserved'
);
assert.ok(
/Demand\s+Multiplier\s+1\.25/i.test(regen),
'Demand Multiplier 1.25 must be preserved'
);
assert.ok(
/Minimum\s+Pressure\s+2\.5/i.test(regen),
'Minimum Pressure must be preserved'
);
assert.ok(
/Required\s+Pressure\s+15/i.test(regen),
'Required Pressure must be preserved'
);
});
test('3. TANKS / CURVES: should preserve MinVol, VolCurve, Overflow and Curves references', () => {
const sampleInp = `[TITLE]
Tank & Curve Test
[JUNCTIONS]
J1 10 10 ;
[RESERVOIRS]
R1 50 ;
[TANKS]
;ID Elevation InitLevel MinLevel MaxLevel Diameter MinVol VolCurve Overflow
T1 45.0 5.0 1.0 10.0 20.0 150.0 CURVE_VOL_1 Yes ;
[PIPES]
P1 R1 J1 100 200 100 0 Open ;
P2 J1 T1 100 150 100 0 Open ;
[CURVES]
;ID X-Value Y-Value
CURVE_VOL_1 1.0 15.0
CURVE_VOL_1 5.0 100.0
CURVE_VOL_1 10.0 250.0
[COORDINATES]
J1 10 10
R1 0 0
T1 20 20
[END]
`;
const model = parseInp(sampleInp);
const tank = model.nodes['T1'];
assert.ok(tank, 'Tank T1 must exist');
assert.equal(tank.type, 'TANK');
const regen = generateInp(model);
// Check that MinVol, VolCurve, Overflow are retained
assert.ok(
regen.includes('CURVE_VOL_1'),
'VolCurve CURVE_VOL_1 must be preserved in regenerated INP'
);
assert.ok(
/T1\s+45(\.0+)?\s+5(\.0+)?\s+1(\.0+)?\s+10(\.0+)?\s+20(\.0+)?\s+150(\.0+)?\s+CURVE_VOL_1/i.test(
regen
),
'Tank parameters including MinVol and VolCurve must be preserved in TANKS section'
);
assert.ok(
regen.includes('15.0') && regen.includes('250.0'),
'CURVES section data must be preserved'
);
});
test('4. CONTROLS / RULES: should not convert numeric setting to CLOSED and should update rawText on edit', () => {
const sampleInp = `[TITLE]
Controls Setting Test
[JUNCTIONS]
J1 10 10 ;
J2 10 10 ;
[RESERVOIRS]
R1 50 ;
[PIPES]
P1 R1 J1 100 200 100 0 Open ;
P2 J1 J2 100 150 100 0 Open ;
[CONTROLS]
LINK P2 1.5 AT TIME 4
LINK P1 OPEN IF NODE J2 BELOW 15
[RULES]
RULE 1
IF NODE J2 PRESSURE < 10
THEN PIPE P1 STATUS = OPEN
[COORDINATES]
J1 10 10
J2 20 10
R1 0 0
[END]
`;
const model = parseInp(sampleInp);
assert.ok(model.controls.length >= 2, 'Controls should be parsed');
// Check first control: should preserve numeric setting 1.5, NOT convert to CLOSED
assert.ok(
!model.controls[0].rawText.includes('CLOSED'),
'Numeric control setting should not be turned into CLOSED'
);
// Update control threshold
const updated = updateControl(model, model.controls[1].id, { value: 25 });
const regen = generateInp(updated);
// Updated control must output 25, not 15
assert.ok(
regen.includes('BELOW 25'),
'Updated control value 25 must appear in regenerated INP'
);
assert.ok(
!regen.includes('BELOW 15'),
'Old control value 15 must NOT appear in regenerated INP'
);
// Rules section must be preserved
assert.ok(regen.includes('RULE 1'), 'RULES section must be preserved');
});
test('5. VALVES, STATUS and REFERENCE CLEANUP: should parse valves, preserve status, and handle deletion references', () => {
const sampleInp = `[TITLE]
Valves and Status Test
[JUNCTIONS]
J1 10 10 ;
J2 10 10 ;
J3 10 10 ;
[RESERVOIRS]
R1 50 ;
[PIPES]
P1 R1 J1 100 200 100 0 Open ;
P2 J2 J3 100 150 100 0 Open ;
[VALVES]
;ID Node1 Node2 Diameter Type Setting MinorLoss
V1 J1 J2 150 PRV 25.0 0 ;
[STATUS]
P2 CLOSED
V1 OPEN
[DEMANDS]
;Junction Demand Pattern Category
J2 5 1 Domestic
J2 15 1 Commercial
[COORDINATES]
J1 10 10
J2 20 10
J3 30 10
R1 0 0
[END]
`;
const model = parseInp(sampleInp);
// Topology validation should NOT report J2 as isolated because V1 connects J1 to J2
const issues = validateTopology(model);
const j2Isolated = issues.some(
(i) => i.target?.id === 'J2' && i.message.includes('고립')
);
assert.equal(
j2Isolated,
false,
'J2 is connected via Valve V1, so it must not be reported as isolated'
);
// Check STATUS preservation in regeneration
const regen = generateInp(model);
assert.ok(
regen.includes('[VALVES]'),
'[VALVES] section must exist in regenerated INP'
);
assert.ok(
/V1\s+J1\s+J2\s+150\s+PRV/i.test(regen),
'Valve V1 must be properly preserved'
);
assert.ok(
/P2\s+CLOSED/i.test(regen) || /P2.*Closed/i.test(regen),
'STATUS CLOSED for P2 must be preserved'
);
});
test('5b. PIPE TO VALVE: conversion moves the link and preserves editable valve output', () => {
const model = parseInp(`[JUNCTIONS]
J1 10 0 ;
J2 10 0 ;
[PIPES]
P1 J1 J2 100 150 120 0.25 Open ;
[COORDINATES]
J1 0 0
J2 100 0
[END]
`);
const modelWithTank = {
...model,
nodes: {
...model.nodes,
T1: {
id: 'T1',
type: 'TANK' as const,
x: 50,
y: 25,
elevation: 15,
initLevel: 5,
minLevel: 0,
maxLevel: 10,
diameter: 8,
minVol: 0,
},
},
};
const converted = convertPipeToValve(modelWithTank, 'P1', 'PRV', 25);
const edited = updateValveAttributes(converted, 'P1', { valveType: 'FCV', setting: 12.5 });
assert.equal(edited.pipes.P1, undefined);
assert.deepEqual(edited.valves.P1, {
id: 'P1',
node1: 'J1',
node2: 'J2',
diameter: 150,
valveType: 'FCV',
setting: 12.5,
minorLoss: 0.25,
});
const regenerated = generateInp(edited);
assert.match(regenerated, /P1\s+J1\s+J2\s+150\s+FCV\s+12\.5\s+0\.25/);
assert.match(regenerated, /\[VALVES\]/);
assert.match(regenerated, /\[TANKS\]/);
const reparsed = parseInp(regenerated);
assert.equal(reparsed.pipes.P1, undefined);
assert.equal(reparsed.valves.P1.valveType, 'FCV');
assert.equal(reparsed.nodes.T1.type, 'TANK');
assert.throws(
() => updateValveAttributes(edited, 'P1', { valveType: 'FCV', setting: 'not-a-number' }),
/숫자/
);
});
test('6. COORDINATES: should preserve geographic lat/lon precision without forced 2-decimal rounding', () => {
const sampleInp = `[TITLE]
Geographic Coordinates Test
[JUNCTIONS]
J1 10 10 ;
[RESERVOIRS]
R1 50 ;
[PIPES]
P1 R1 J1 100 200 100 0 Open ;
[COORDINATES]
J1 126.9784321 37.5665432
R1 126.9741234 37.5621234
[END]
`;
const model = parseInp(sampleInp);
const j1 = model.nodes['J1'];
assert.equal(
j1.x,
126.9784321,
'High precision longitude must be preserved in model'
);
assert.equal(
j1.y,
37.5665432,
'High precision latitude must be preserved in model'
);
const regen = generateInp(model);
assert.ok(
regen.includes('126.9784321'),
'Regenerated INP must contain 126.9784321, not truncated to 126.98'
);
assert.ok(
regen.includes('37.5665432'),
'Regenerated INP must contain 37.5665432, not truncated to 37.57'
);
});
test('7. SHORT PIPE SPLIT: should strictly conserve L1 + L2 = L_old without arbitrary >=1 truncation and split MinorLoss K correctly', () => {
const sampleInp = `[TITLE]
Short Pipe Split Test
[JUNCTIONS]
J1 10 10 ;
J2 10 10 ;
[RESERVOIRS]
R1 50 ;
[PIPES]
P1 R1 J1 100 200 100 0 Open ;
P_SHORT J1 J2 0.8 150 100 2.4 Open ;
[COORDINATES]
J1 10 10
J2 10.8 10
R1 0 0
[END]
`;
const model = parseInp(sampleInp);
const originalPipe = model.pipes['P_SHORT'];
assert.equal(originalPipe.length, 0.8);
assert.equal(originalPipe.minorLoss, 2.4);
// Split P_SHORT at 50%
const splitRes = splitPipe(model, 'P_SHORT', 0.5);
const pA = splitRes.model.pipes[splitRes.retainedPipeId];
const pB = splitRes.model.pipes[splitRes.newPipeId];
// Length must strictly sum to 0.8 and both segments must be strictly positive
assert.ok(pA.length > 0, 'L1 must be strictly greater than 0');
assert.ok(pB.length > 0, 'L2 must be strictly greater than 0');
const sumLen = Math.round((pA.length + pB.length) * 1000) / 1000;
assert.equal(
sumLen,
0.8,
'Split lengths must sum exactly to original length 0.8, NOT forced to 1.0 + 1.0 = 2.0'
);
// Minor loss K should NOT be doubled to 2.4 + 2.4 = 4.8!
const sumK = Math.round((pA.minorLoss + pB.minorLoss) * 100) / 100;
assert.equal(
sumK,
2.4,
'Total minor loss K must be conserved (e.g. 1.2 + 1.2 or assigned to one segment), NOT duplicated to double total loss'
);
// Ultra-short pipe (0.05 m) with K = 0.3 split case
const ultraShortModel = {
...model,
pipes: {
...model.pipes,
P_ULTRA: { ...originalPipe, id: 'P_ULTRA', length: 0.05, minorLoss: 0.3 },
},
};
const ultraRes = splitPipe(ultraShortModel, 'P_ULTRA', 0.5);
const uA = ultraRes.model.pipes[ultraRes.retainedPipeId];
const uB = ultraRes.model.pipes[ultraRes.newPipeId];
assert.ok(uA.length > 0, 'Ultra-short L1 must be > 0');
assert.ok(uB.length > 0, 'Ultra-short L2 must be > 0');
assert.equal(Math.round((uA.length + uB.length) * 10000) / 10000, 0.05, 'L1 + L2 must strictly equal 0.05m');
assert.equal(Math.round((uA.minorLoss + uB.minorLoss) * 10000) / 10000, 0.3, 'K1 + K2 must strictly equal 0.3');
});
import {
getUnitSystem,
convertNetworkUnits,
checkUnitConversion,
} from '../src/unitSystem.ts';
test('8. UNIT CONVERSION: SI <-> US and flow conversion within SI preserving dimensionless values and coordinates', () => {
const sampleInp = `[TITLE]
Unit Conversion Test
[OPTIONS]
Units GPM
Headloss H-W
[JUNCTIONS]
J1 100.0 500.0 1 ;
[RESERVOIRS]
R1 250.0 ;
[TANKS]
T1 200.0 10.0 2.0 15.0 50.0 5000.0 ;
[PIPES]
P1 R1 J1 5280.0 12.0 120 1.5 Open ;
P2 J1 T1 2640.0 10.0 130 0.8 Open ;
[CONTROLS]
LINK P1 OPEN IF NODE T1 BELOW 5
[PATTERNS]
1 1.2 0.8 1.5
[COORDINATES]
J1 126.9754321 37.5654321
R1 126.9700000 37.5600000
T1 126.9800000 37.5700000
[END]
`;
const model = parseInp(sampleInp);
assert.equal(getUnitSystem('GPM'), 'US');
assert.equal(getUnitSystem('LPS'), 'SI');
// Convert US (GPM, ft, in) to SI (LPS, m, mm)
const check = checkUnitConversion(model, 'LPS');
assert.equal(check.canConvert, true);
assert.equal(check.sourceSystem, 'US');
assert.equal(check.targetSystem, 'SI');
const converted = convertNetworkUnits(model, 'LPS');
const siModel = converted.model;
// Length: 5280 ft = 1609.34 m
assert.equal(siModel.pipes['P1'].length, 1609.34);
// Diameter: 12 in = 304.8 mm
assert.equal(siModel.pipes['P1'].diameter, 304.8);
// Roughness: C=120 conserved!
assert.equal(siModel.pipes['P1'].roughness, 120);
// Minor loss: K=1.5 conserved!
assert.equal(siModel.pipes['P1'].minorLoss, 1.5);
// Demand: 500 GPM = 500 * 0.0630902 = 31.545 LPS
assert.equal(siModel.nodes['J1'].demand, 31.545);
// Elevation: 100 ft = 30.48 m
assert.equal(siModel.nodes['J1'].elevation, 30.48);
// Tank diameter: 50 ft = 15.24 m
assert.equal(siModel.nodes['T1'].diameter, 15.24);
// GIS coordinates must NOT be modified
assert.equal(siModel.nodes['J1'].x, 126.9754321);
assert.equal(siModel.nodes['J1'].y, 37.5654321);
// Control threshold: T1 below 5 ft -> 5 * 0.3048 = 1.52 m
assert.equal(siModel.controls[0].value, 1.52);
assert.ok(siModel.controls[0].rawText.includes('1.52'));
// Intra-SI conversion: LPS -> CMH (1 LPS = 3.6 CMH)
const cmhConverted = convertNetworkUnits(siModel, 'CMH');
const cmhModel = cmhConverted.model;
// Length/diameter untouched in intra-SI
assert.equal(cmhModel.pipes['P1'].length, 1609.34);
// Demand: 31.545 LPS * 3.6 = 113.562 CMH
assert.equal(cmhModel.nodes['J1'].demand, 113.562);
});
test('9. ROUNDTRIP CONVERSION: US -> SI -> US should recover original dimensions within tolerance', () => {
const sampleInp = `[TITLE]
Roundtrip Test
[OPTIONS]
Units GPM
Headloss H-W
[JUNCTIONS]
J1 120.0 250.0 ;
[RESERVOIRS]
R1 300.0 ;
[PIPES]
P1 R1 J1 3500.0 14.0 120 0.5 Open ;
[COORDINATES]
J1 100 100
R1 0 0
[END]
`;
const model = parseInp(sampleInp);
const toSI = convertNetworkUnits(model, 'LPS').model;
const backToUS = convertNetworkUnits(toSI, 'GPM').model;
// Tolerances: allow 0.1% or 0.1 unit rounding drift
const lenDiff = Math.abs(backToUS.pipes['P1'].length - 3500.0);
assert.ok(lenDiff < 1.0, `Length recovered within 1 ft: actual ${backToUS.pipes['P1'].length}`);
const diaDiff = Math.abs(backToUS.pipes['P1'].diameter - 14.0);
assert.ok(diaDiff < 0.1, `Diameter recovered within 0.1 in: actual ${backToUS.pipes['P1'].diameter}`);
const demandDiff = Math.abs((backToUS.nodes['J1'].demand ?? 0) - 250.0);
assert.ok(demandDiff < 0.5, `Demand recovered within 0.5 GPM: actual ${backToUS.nodes['J1'].demand}`);
});
test('10. STALE RESULTS PRESERVATION: computeIsStale and saveActiveScenarioState must detect and clear outdated results', () => {
const sampleInp = `[TITLE]
Stale Check
[OPTIONS]
Units LPS
[JUNCTIONS]
J1 10 10 ;
[RESERVOIRS]
R1 50 ;
[PIPES]
P1 R1 J1 100 200 100 0 Open ;
[COORDINATES]
J1 10 10
R1 0 0
[END]
`;
const model = parseInp(sampleInp);
const inpA = generateInp(model);
// computeIsStale: identical model text -> not stale
assert.equal(computeIsStale(inpA, inpA), false, 'Identical model text must not be flagged stale');
// No analysis has ever run for this model text -> stale (must force analysis before export)
assert.equal(computeIsStale(inpA, null), true, 'A model with no prior analysis snapshot must be stale');
// Simulate editing (elevation change) - real generateInp output must differ
const editedModel = {
...model,
nodes: { ...model.nodes, J1: { ...model.nodes['J1'], elevation: 25 } },
};
const inpB = generateInp(editedModel);
assert.notEqual(inpA, inpB, 'Edited model must regenerate different INP text');
assert.equal(computeIsStale(inpB, inpA), true, 'Model edited after last analysis snapshot must be stale');
// saveActiveScenarioState: auto-save on scenario switch must never carry forward
// a result that no longer matches the saved (edited) model text.
const fakeResult = { engine: { runtime: 'wasm', version: '2.3.5' }, timeSeconds: 0, units: { flow: 'LPS', pressure: 'm' }, nodes: {}, links: {} } as unknown as SimulationResult;
const scenarios: Scenario[] = [
{ id: 'base', name: 'base', inpStr: inpA, result: fakeResult, createdAt: 'now' },
];
const savedStale = saveActiveScenarioState(scenarios, 'base', inpB, fakeResult, true);
assert.equal(savedStale[0].inpStr, inpB, 'Edited model text must be persisted even when the result is stale');
assert.equal(savedStale[0].result, null, 'A stale result must be cleared, never mislabeled as matching the saved model');
const savedFresh = saveActiveScenarioState(scenarios, 'base', inpA, fakeResult, false);
assert.equal(savedFresh[0].result, fakeResult, 'A non-stale result must be preserved when saving scenario state');
});
test('11. EPS TIMESTAMPS: computeComparison must match Native/WASM series by real timestamp, not array index', () => {
const buildNode = (demandByTime: number[]) => ({
id: 'J1',
type: 0,
coordinates: null,
demand: demandByTime[0],
head: 0,
pressure: 0,
timeSeries: { demand: demandByTime, head: demandByTime.map(() => 0), pressure: demandByTime.map(() => 0) },
});
// Server reports regular hourly steps; WASM reports an extra irregular step at 1800s.
// A naive index-based comparison would wrongly line up server's 3600s reading against
// WASM's 1800s reading (index 1 in both arrays).
const server = {
engine: { runtime: 'native', version: '2.3.5' },
timeSeconds: 7200,
timeSteps: [0, 3600, 7200],
units: { flow: 'LPS', pressure: 'm' },
nodes: { J1: buildNode([10, 20, 30]) },
links: {},
} as unknown as SimulationResult;
const wasm = {
engine: { runtime: 'wasm', version: '2.3.5' },
timeSeconds: 7200,
timeSteps: [0, 1800, 3600, 7200],
units: { flow: 'LPS', pressure: 'm' },
// Bogus value 999 sits at 1800s, a timestamp the server never reports.
nodes: { J1: buildNode([10, 999, 20, 30]) },
links: {},
} as unknown as SimulationResult;
const result = computeComparison(server, wasm);
assert.equal(
result.maxDiffs.demand,
0,
`Real-timestamp matching must find 0 diff (10/20/30 line up at 0/3600/7200s); index-based matching would report ~979`
);
});
test('12. CONVERGENCE WARNING CHECK: inspectConvergence must classify actual engine report text, never hardcode success', () => {
const reportWithWarning = `
Page 1
EPANET 2.3.5
WARNING: Negative pressures occurred at 04:00:00.
System unbalanced at 05:00:00.
`;
const warned = inspectConvergence(reportWithWarning);
assert.equal(warned.hasWarning, true, 'Report with warnings must be flagged as hasWarning');
assert.match(warned.status, /경고|불균형/, 'Status text must reflect the warning');
const cleanReport =
'Page 1\nEPANET 2.3.5\nHydraulic Status\nAnalysis begun...\nAnalysis completed successfully.\n' +
'x'.repeat(60);
const clean = inspectConvergence(cleanReport);
assert.equal(clean.hasWarning, false, 'A clean report with no warning markers must not be flagged');
assert.match(clean.status, /정상 수렴/, 'Clean report must report normal convergence');
const missing = inspectConvergence(undefined);
assert.equal(missing.hasWarning, false, 'Missing report must not be flagged as a warning');
assert.match(missing.status, /미실행/, 'Missing report must state analysis has not run, never claim success');
});
test('13. RE-OPEN IN ENGINE + FULL EPS: every engine return code must be 0 across all hydraulic periods', () => {
const sampleInp = `[TITLE]
Full Synthesis Engine Test
[OPTIONS]
Units LPS
Headloss H-W
[JUNCTIONS]
J1 10 15 ;
J2 12 20 ;
[RESERVOIRS]
R1 60 ;
[PIPES]
P1 R1 J1 300 200 120 0 Open ;
P2 J1 J2 250 150 120 0 Open ;
[PATTERNS]
1 1.0 1.2 0.8
[TIMES]
Duration 7200
Hydraulic Timestep 3600
Pattern Timestep 3600
[COORDINATES]
J1 10 10
J2 20 10
R1 0 0
[END]
`;
const model = parseInp(sampleInp);
const regen = generateInp(model);
assert.ok(regen.trim().endsWith('[END]'), 'Must terminate with [END]');
assert.ok(regen.includes('[PIPES]'), 'Must include [PIPES]');
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'spipe_test_'));
const inpPath = path.join(tmpDir, 'test_regen.inp');
const rptPath = path.join(tmpDir, 'test_regen.rpt');
const outPath = path.join(tmpDir, 'test_regen.out');
const jsonPath = path.join(tmpDir, 'result.json');
fs.writeFileSync(inpPath, regen);
const pythonExe = path.resolve('.venv/Scripts/python.exe');
const pyFile = path.join(tmpDir, 'runner.py');
fs.writeFileSync(
pyFile,
`import ctypes, os, sys, json
lib = ctypes.CDLL(os.path.abspath('64bit/epanet2.dll'))
ph = ctypes.c_void_p()
lib.EN_getnodevalue.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_int, ctypes.POINTER(ctypes.c_double)]
lib.EN_getnodevalue.restype = ctypes.c_int
def check(rc, step):
if rc != 0:
print(json.dumps({'failedStep': step, 'rc': rc}))
sys.exit(1)
check(lib.EN_createproject(ctypes.byref(ph)), 'createproject')
check(lib.EN_open(ph, sys.argv[1].encode('utf-8'), sys.argv[2].encode('utf-8'), sys.argv[3].encode('utf-8')), 'open')
check(lib.EN_openH(ph), 'openH')
check(lib.EN_initH(ph, 0), 'initH')
steps = []
t = ctypes.c_long()
tstep = ctypes.c_long(1)
while tstep.value != 0 or not steps:
check(lib.EN_runH(ph, ctypes.byref(t)), f'runH@{len(steps)}')
pressure = ctypes.c_double()
check(lib.EN_getnodevalue(ph, 1, 11, ctypes.byref(pressure)), f'getnodevalue@{len(steps)}')
steps.append({'time': t.value, 'pressure': pressure.value})
check(lib.EN_nextH(ph, ctypes.byref(tstep)), f'nextH@{len(steps)}')
if tstep.value == 0:
break
check(lib.EN_closeH(ph), 'closeH')
check(lib.EN_close(ph), 'close')
check(lib.EN_deleteproject(ph), 'deleteproject')
with open(sys.argv[4], 'w') as f:
json.dump({'steps': steps}, f)
print('EPANET_OPEN_SOLVE_OK')
`
);
const pythonCmd = `"${pythonExe}" "${pyFile}" "${inpPath}" "${rptPath}" "${outPath}" "${jsonPath}"`;
try {
const stdout = execSync(pythonCmd, { encoding: 'utf-8' });
assert.ok(stdout.includes('EPANET_OPEN_SOLVE_OK'), `Every engine call must return rc=0 across the full EPS run; runner output: ${stdout}`);
const parsed = JSON.parse(fs.readFileSync(jsonPath, 'utf-8')) as { steps: { time: number; pressure: number }[] };
assert.ok(
parsed.steps.length >= 2,
`A 7200s duration with 3600s hydraulic timestep must produce >= 2 EPS periods; got ${parsed.steps.length}`
);
for (const s of parsed.steps) {
assert.ok(
Number.isFinite(s.pressure) && Math.abs(s.pressure) < 1000,
`Node pressure at t=${s.time}s must be a real, in-range value (LPS/m units), got ${s.pressure}`
);
}
} finally {
fs.rmSync(tmpDir, { recursive: true, force: true });
}
});
test('14. CFS FLOW UNIT: checkUnitConversion and convertNetworkUnits must support CFS (previously missing from the flow-unit table)', () => {
const sampleInp = `[TITLE]
CFS Test
[OPTIONS]
Units GPM
[JUNCTIONS]
J1 100.0 500.0 ;
[RESERVOIRS]
R1 250.0 ;
[PIPES]
P1 R1 J1 100 12 120 0 Open ;
[COORDINATES]
J1 10 10
R1 0 0
[END]
`;
const model = parseInp(sampleInp);
const check = checkUnitConversion(model, 'CFS');
assert.equal(check.canConvert, true, 'CFS must be recognized as a valid, convertible flow unit');
assert.equal(check.targetSystem, 'US');
const converted = convertNetworkUnits(model, 'CFS').model;
// 500 GPM = 500 * 0.0630901964 LPS = 31.5450982 LPS; / 28.316846592 LPS-per-CFS = 1.11406... CFS
const expectedCfs = Math.round(((500 * 0.0630901964) / 28.316846592) * 1000) / 1000;
assert.equal(converted.nodes['J1'].demand, expectedCfs);
});
test('15. SPECIFIC GRAVITY: pressure-quantity conversions must scale with the model Specific Gravity, not assume water (SG=1)', () => {
const sampleInp = `[TITLE]
SG Test
[OPTIONS]
Units GPM
Specific Gravity 1.2
Minimum Pressure 20
[JUNCTIONS]
J1 100.0 500.0 ;
[RESERVOIRS]
R1 250.0 ;
[PIPES]
P1 R1 J1 100 12 120 0 Open ;
[COORDINATES]
J1 10 10
R1 0 0
[END]
`;
const modelSg = parseInp(sampleInp);
assert.equal(modelSg.options.specificGravity, 1.2, 'Specific Gravity 1.2 must be parsed from OPTIONS');
const convertedSg = convertNetworkUnits(modelSg, 'LPS').model;
// 20 psi -> m of head for SG=1.2: (20 * 0.70307) / 1.2 = 11.7178.. -> 11.72
assert.equal(convertedSg.options.minimumPressure, 11.72);
const sampleInpDefaultSg = sampleInp.replace('Specific Gravity 1.2', 'Specific Gravity 1.0');
const modelDefault = parseInp(sampleInpDefaultSg);
const convertedDefault = convertNetworkUnits(modelDefault, 'LPS').model;
// Same 20 psi with SG=1.0 using EPANET's PSIperFT=0.4333: 20 * (0.3048/0.4333) = 14.0688 -> 14.07
assert.equal(convertedDefault.options.minimumPressure, 14.07);
assert.notEqual(
convertedSg.options.minimumPressure,
convertedDefault.options.minimumPressure,
'Specific Gravity must actually change the converted pressure value'
);
});
test('16. UNSAFE CONSTRUCT BLOCKING: RULES and numeric STATUS entries abort the conversion; structured DEMANDS convert with the network', () => {
const demandsInp = `[TITLE]
Demands Block Test
[OPTIONS]
Units GPM
[JUNCTIONS]
J1 100.0 ;
J2 100.0 ;
[RESERVOIRS]
R1 250.0 ;
[PIPES]
P1 R1 J1 100 12 120 0 Open ;
P2 J1 J2 100 12 120 0 Open ;
[DEMANDS]
J2 5 1 Domestic
J2 15 1 Commercial
[COORDINATES]
J1 10 10
J2 20 10
R1 0 0
[END]
`;
const demandsModel = parseInp(demandsInp);
// [DEMANDS] is now parsed into model.extras, so its flow values are
// converted together with every other flow quantity (never left stale).
const demandsCheck = checkUnitConversion(demandsModel, 'LPS');
assert.equal(demandsCheck.canConvert, true, 'structured [DEMANDS] no longer blocks conversion');
const convertedDemands = convertNetworkUnits(demandsModel, 'LPS').model;
const j2 = convertedDemands.extras!.demands['J2'];
assert.equal(j2.length, 2);
assert.ok(Math.abs(j2[0].demand - 5 * 0.0630902) < 1e-4, `5 GPM -> LPS, got ${j2[0].demand}`);
assert.ok(Math.abs(j2[1].demand - 15 * 0.0630902) < 1e-4);
assert.match(generateInp(convertedDemands), /\[DEMANDS\][\s\S]*J2\s+0\.31/);
// A model without the structured extras (built outside parseInp) still blocks.
const legacy = { ...demandsModel, extras: undefined };
const legacyCheck = checkUnitConversion(legacy, 'LPS');
assert.equal(legacyCheck.canConvert, false, 'raw-only [DEMANDS] must still block');
assert.match(legacyCheck.reason ?? '', /DEMANDS/);
const rulesInp = demandsInp.replace(
'[DEMANDS]\n J2 5 1 Domestic\n J2 15 1 Commercial\n',
'[RULES]\n RULE 1\n IF NODE J2 PRESSURE < 10\n THEN PIPE P1 STATUS = OPEN\n'
);
const rulesModel = parseInp(rulesInp);
const rulesCheck = checkUnitConversion(rulesModel, 'LPS');
assert.equal(rulesCheck.canConvert, false, '[RULES] section must block automatic conversion');
assert.match(rulesCheck.reason ?? '', /RULES/);
const statusInp = demandsInp.replace(
'[DEMANDS]\n J2 5 1 Domestic\n J2 15 1 Commercial\n',
'[STATUS]\n P2 2500\n'
);
const statusModel = parseInp(statusInp);
const statusCheck = checkUnitConversion(statusModel, 'LPS');
assert.equal(statusCheck.canConvert, false, '[STATUS] numeric initial setting must block automatic conversion');
assert.match(statusCheck.reason ?? '', /STATUS/);
});
test('17. COORDINATE EDIT PROPAGATION: a node move must survive regeneration despite a stale rawX/rawY from parsing', () => {
const sampleInp = `[TITLE]
Node Move Test
[JUNCTIONS]
J1 10 10 ;
[RESERVOIRS]
R1 50 ;
[PIPES]
P1 R1 J1 100 200 100 0 Open ;
[COORDINATES]
J1 100.5 200.5
R1 0 0
[END]
`;
const model = parseInp(sampleInp);
assert.equal(model.nodes['J1'].rawX, '100.5', 'Parsed rawX must retain the original text');
// Simulate exactly what handleNodeDragEnd/handleUpdateNode do: update x/y only,
// without touching rawX/rawY (this is the real production code path).
const moved = {
...model,
nodes: {
...model.nodes,
J1: { ...model.nodes['J1'], x: 555.123, y: 777.456 },
},
};
const regen = generateInp(moved);
assert.ok(regen.includes('555.123'), 'Regenerated INP must reflect the moved X coordinate');
assert.ok(regen.includes('777.456'), 'Regenerated INP must reflect the moved Y coordinate');
assert.ok(!regen.includes('100.5 '), 'Stale rawX must never override an actual coordinate edit');
});
test('18. CRS-AWARE LENGTH: distance calculation must respect the coordinate reference system and length unit system', () => {
// Two points ~0.01 degrees apart in longitude near the equator: ~1112 m (haversine).
const geoDist = calculateGeoAwareDistance({ x: 0, y: 0 }, { x: 0.01, y: 0 }, 'EPSG:4326', 'SI');
assert.ok(geoDist.isPhysical, 'EPSG:4326 must be treated as physically meaningful');
assert.ok(
Math.abs(geoDist.distance - 1113.2) < 5,
`Expected ~1113m for 0.01 deg longitude at the equator, got ${geoDist.distance}`
);
// Same physical distance, but requested in US units (feet) must scale by 3.28084.
const geoDistUS = calculateGeoAwareDistance({ x: 0, y: 0 }, { x: 0.01, y: 0 }, 'EPSG:4326', 'US');
assert.ok(
Math.abs(geoDistUS.distance / geoDist.distance - 3.280839895013123) < 1e-6,
'US unit system must convert the same physical distance to feet'
);
// Projected meters (EPSG:5179): Euclidean distance is already in meters, no haversine needed.
const projDist = calculateGeoAwareDistance({ x: 1000000, y: 2000000 }, { x: 1000300, y: 2000400 }, 'EPSG:5179', 'SI');
assert.equal(projDist.distance, 500, 'Projected meters must use plain Euclidean distance (3-4-5 triangle)');
// LOCAL (arbitrary planar) coordinates carry no real-world scale.
const localDist = calculateGeoAwareDistance({ x: 0, y: 0 }, { x: 3, y: 4 }, 'LOCAL', 'SI');
assert.equal(localDist.isPhysical, false, 'LOCAL coordinate systems must be flagged as not physically meaningful');
assert.equal(localDist.distance, 5, 'LOCAL distance must be plain Euclidean (3-4-5 triangle), not unit-scaled');
// A US-unit network on a LOCAL crs must NOT apply the meters->feet factor to
// an already-scaleless coordinate space (e.g. Net1.inp: GPM units, LOCAL crs,
// 10 units apart must recalc to 10, not 32.8).
const localDistUS = calculateGeoAwareDistance({ x: 0, y: 0 }, { x: 10, y: 0 }, 'LOCAL', 'US');
assert.equal(localDistUS.distance, 10, 'LOCAL + US unit system must not fabricate a feet scale for arbitrary local coordinates');
// EPSG:3857: Raw Euclidean in 3857 would be inflated by ~26% in Korea (~1261m for 1000m).
// calculateGeoAwareDistance projects via EPSG:5179, yielding the un-distorted ~1000m metric distance.
const seoul3857P1 = { x: 14135169.54, y: 4518770.83 }; // Seoul City Hall
const seoul3857P2 = { x: 14136431.14, y: 4518770.83 }; // ~1km East in 3857 (raw dx = 1261.6m)
const dist3857 = calculateGeoAwareDistance(seoul3857P1, seoul3857P2, 'EPSG:3857', 'SI');
assert.ok(dist3857.isPhysical, 'EPSG:3857 distance must be physically meaningful');
assert.ok(
Math.abs(dist3857.distance - 1000.8) < 2,
`EPSG:3857 distance must be corrected to ~1000.8m (un-distorted), got ${dist3857.distance}`
);
// Sanity-check the underlying haversine function directly against a known reference.
const oneDegreeLon = haversineMeters(0, 0, 0, 1);
assert.ok(Math.abs(oneDegreeLon - 111320) < 500, `1 degree of longitude at the equator should be ~111.32km, got ${oneDegreeLon}`);
});
test('19. AT TIME CONTROL PRESERVATION: editing a time-based control must not silently drop its AT TIME clause', () => {
const sampleInp = `[TITLE]
Time Control Test
[JUNCTIONS]
J1 10 10 ;
J2 10 10 ;
[RESERVOIRS]
R1 50 ;
[PIPES]
P1 R1 J1 100 200 100 0 Open ;
P2 J1 J2 100 150 100 0 Open ;
[CONTROLS]
LINK P2 CLOSED AT TIME 4
[COORDINATES]
J1 10 10
J2 20 10
R1 0 0
[END]
`;
const model = parseInp(sampleInp);
const ctrl = model.controls.find((c) => c.linkId === 'P2');
assert.ok(ctrl, 'Time-based control for P2 must be parsed');
assert.equal(ctrl!.atClause, 'AT TIME 4', 'AT TIME clause must be captured verbatim');
assert.equal(ctrl!.timeSec, 4 * 3600, 'AT TIME 4 must be interpreted as 4 hours (14400 seconds)');
// Edit only the status (simulating a UI status-field edit), not the time clause.
const updated = updateControl(model, ctrl!.id, { status: 'OPEN' });
const regen = generateInp(updated);
assert.ok(regen.includes('AT TIME 4'), 'AT TIME 4 must be preserved after editing the control status');
assert.ok(/LINK\s+P2\s+OPEN\s+AT TIME 4/.test(regen), 'Updated status OPEN must combine with the preserved AT TIME clause');
});
test('20. MODEL SNAPSHOT NORMALIZATION: a freshly loaded and analyzed model must not be immediately flagged stale', () => {
// Realistic desktop-authored spacing, deliberately different from generateInp's
// fixed-width output - this is what App.tsx actually receives from file upload.
const rawUploadedInp = `[TITLE]
Snapshot Normalization Test
[JUNCTIONS]
J1 10 15 ;
[RESERVOIRS]
R1 60 ;
[PIPES]
P1 R1 J1 300 200 120 0 Open ;
[COORDINATES]
J1 10 10
R1 0 0
[END]
`;
const model = parseInp(rawUploadedInp);
// Bug (pre-fix): App.tsx stored the raw submitted text verbatim as the result
// snapshot. Comparing it directly against generateInp(model) output falsely
// reports staleness even though zero edits were made.
const buggySnapshot = rawUploadedInp;
assert.equal(
computeIsStale(generateInp(model), buggySnapshot),
true,
'Demonstrates the bug: comparing regenerated text against raw source text falsely reports staleness'
);
// Fix: normalize through parse+regenerate (what App.tsx's normalizeInp does)
// before storing the snapshot, so the comparison is apples-to-apples.
const normalizedSnapshot = generateInp(parseInp(rawUploadedInp));
assert.equal(
computeIsStale(generateInp(model), normalizedSnapshot),
false,
'A freshly loaded and analyzed model must not be flagged stale immediately after load'
);
// Idempotency: normalizing an already-regenerated string must be a no-op,
// so the same snapshot logic works uniformly whether the source is a raw
// upload or output from a prior generateInp call (e.g. scenario switching).
const once = generateInp(model);
const twice = generateInp(parseInp(once));
assert.equal(once, twice, 'generateInp(parseInp(x)) must be idempotent on already-regenerated INP text');
});
test('21. OFFICIAL EXAMPLE NETWORKS (Net1/Net2/Net3): parse -> generateInp -> re-open and solve in the real EPANET 2.3.5 C DLL', () => {
// Source: github.com/OpenWaterAnalytics/EPANET (dev branch, example-networks/), MIT-licensed
// public-domain-origin USEPA example networks. See public/EXAMPLE_NETWORKS.md.
const networks = [
{ name: 'Net1', path: 'public/Net1.inp', expectedNodes: 11, expectedLinks: 13 },
{ name: 'Net2', path: 'public/Net2.inp', expectedNodes: 36, expectedLinks: 40 },
{ name: 'Net3', path: 'public/Net3.inp', expectedNodes: 97, expectedLinks: 119 },
];
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'spipe_examples_'));
try {
for (const net of networks) {
const raw = fs.readFileSync(net.path, 'utf-8');
const model = parseInp(raw);
const nodeCount = Object.keys(model.nodes).length;
const linkCount =
Object.keys(model.pipes).length + Object.keys(model.pumps).length + Object.keys(model.valves).length;
assert.equal(nodeCount, net.expectedNodes, `${net.name}: parsed node count must match the official network`);
assert.equal(linkCount, net.expectedLinks, `${net.name}: parsed link count must match the official network`);
const regen = generateInp(model);
assert.ok(regen.trim().endsWith('[END]'), `${net.name}: regenerated INP must terminate with [END]`);
// Round-trip: re-parsing the regenerated text must preserve identical topology counts.
const reparsed = parseInp(regen);
const reparsedNodeCount = Object.keys(reparsed.nodes).length;
const reparsedLinkCount =
Object.keys(reparsed.pipes).length + Object.keys(reparsed.pumps).length + Object.keys(reparsed.valves).length;
assert.equal(reparsedNodeCount, nodeCount, `${net.name}: round-trip node count must be conserved`);
assert.equal(reparsedLinkCount, linkCount, `${net.name}: round-trip link count must be conserved`);
// Actually invoke the bundled EPANET 2.3.5 DLL to prove the regenerated INP re-opens
// and solves without syntax/physics errors (rc=0 on every call).
const inpPath = path.join(tmpDir, `${net.name}_regen.inp`);
const rptPath = path.join(tmpDir, `${net.name}_regen.rpt`);
const outPath = path.join(tmpDir, `${net.name}_regen.out`);
fs.writeFileSync(inpPath, regen);
const pythonExe = path.resolve('.venv/Scripts/python.exe');
const pyFile = path.join(tmpDir, `${net.name}_runner.py`);
fs.writeFileSync(
pyFile,
`import ctypes, os, sys
lib = ctypes.CDLL(os.path.abspath('64bit/epanet2.dll'))
ph = ctypes.c_void_p()
def check(rc, step):
if rc != 0:
sys.stderr.write(f'FAILED at {step}: rc={rc}\\n')
sys.exit(1)
check(lib.EN_createproject(ctypes.byref(ph)), 'createproject')
check(lib.EN_open(ph, sys.argv[1].encode('utf-8'), sys.argv[2].encode('utf-8'), sys.argv[3].encode('utf-8')), 'open')
check(lib.EN_openH(ph), 'openH')
check(lib.EN_initH(ph, 0), 'initH')
t = ctypes.c_long()
check(lib.EN_runH(ph, ctypes.byref(t)), 'runH')
check(lib.EN_closeH(ph), 'closeH')
check(lib.EN_close(ph), 'close')
check(lib.EN_deleteproject(ph), 'deleteproject')
print('EPANET_OPEN_SOLVE_OK')
`
);
const pythonCmd = `"${pythonExe}" "${pyFile}" "${inpPath}" "${rptPath}" "${outPath}"`;
const stdout = execSync(pythonCmd, { encoding: 'utf-8' });
assert.ok(
stdout.includes('EPANET_OPEN_SOLVE_OK'),
`${net.name}: regenerated INP must open and solve in the real EPANET 2.3.5 C DLL (rc=0 on every call)`
);
}
} finally {
fs.rmSync(tmpDir, { recursive: true, force: true });
}
});
test('22. TOLERANCE-BASED COMPARISON: absTol + relTol criterion and near-zero relative diff separation', () => {
// 1. Verify default tolerances as specified by requirements
assert.deepEqual(DEFAULT_TOLERANCES.head, { absTol: 1e-4, relTol: 1e-8 });
assert.deepEqual(DEFAULT_TOLERANCES.pressure, { absTol: 1e-4, relTol: 1e-8 });
assert.deepEqual(DEFAULT_TOLERANCES.demand, { absTol: 1e-3, relTol: 1e-8 });
assert.deepEqual(DEFAULT_TOLERANCES.flow, { absTol: 1e-3, relTol: 1e-8 });
assert.deepEqual(DEFAULT_TOLERANCES.velocity, { absTol: 1e-5, relTol: 1e-8 });
assert.deepEqual(DEFAULT_TOLERANCES.headloss, { absTol: 1e-5, relTol: 1e-8 });
// 2. Near-zero test: Pipe flow is 1e-6 vs 2e-6 (relative diff is 50%, yet absolute diff is 1e-6 << absTol 1e-3)
const serverNearZero = {
engine: { runtime: 'native', version: '2.3.5' },
timeSeconds: 0,
units: { flow: 'GPM', pressure: 'psi' },
nodes: {},
links: {
P1: { id: 'P1', type: 0, fromNode: 'N1', toNode: 'N2', vertices: [], flow: 1e-6, velocity: 1e-6, headloss: 1e-6 },
},
} as unknown as SimulationResult;
const wasmNearZero = {
engine: { runtime: 'wasm', version: '2.3.5' },
timeSeconds: 0,
units: { flow: 'GPM', pressure: 'psi' },
nodes: {},
links: {
P1: { id: 'P1', type: 0, fromNode: 'N1', toNode: 'N2', vertices: [], flow: 2e-6, velocity: 2e-6, headloss: 2e-6 },
},
} as unknown as SimulationResult;
const resNearZero = computeComparison(serverNearZero, wasmNearZero);
// Even though relative diff is 0.5 (50%), it must PASS because diff (1e-6) <= absTol + relTol * max
assert.equal(resNearZero.passed, true, 'Near-zero diff must pass tolerance check');
assert.equal(resNearZero.toleranceViolations.length, 0, 'No violations should occur within tolerance');
assert.equal(resNearZero.nearZeroCounts.flow, 1, 'Near-zero denominator must be tracked in nearZeroCounts');
assert.equal(resNearZero.maxRelativeDiffs.flow, 0.5, 'Raw maxRelativeDiff is still tracked');
assert.equal(resNearZero.maxSignificantRelativeDiffs.flow, 0, 'Significant relative diff excludes near-zero values');
// 3. Significant value test: Pipe flow is 100.0 vs 100.00005 (diff is 5e-5 <= absTol 1e-3, scale is 100 >> absTol)
const serverSig = {
engine: { runtime: 'native', version: '2.3.5' },
timeSeconds: 0,
units: { flow: 'GPM', pressure: 'psi' },
nodes: {},
links: {
P2: { id: 'P2', type: 0, fromNode: 'N1', toNode: 'N2', vertices: [], flow: 100.0, velocity: 1.0, headloss: 0.1 },
},
} as unknown as SimulationResult;
const wasmSig = {
engine: { runtime: 'wasm', version: '2.3.5' },
timeSeconds: 0,
units: { flow: 'GPM', pressure: 'psi' },
nodes: {},
links: {
P2: { id: 'P2', type: 0, fromNode: 'N1', toNode: 'N2', vertices: [], flow: 100.00005, velocity: 1.0, headloss: 0.1 },
},
} as unknown as SimulationResult;
const resSig = computeComparison(serverSig, wasmSig);
assert.equal(resSig.passed, true, 'Significant value within tolerance must pass');
assert.equal(resSig.nearZeroCounts.flow, 0, 'Denominator 100 is not near-zero');
assert.ok(
Math.abs(resSig.maxSignificantRelativeDiffs.flow - 5e-7) < 1e-9,
'Significant relative diff must capture true non-near-zero relative difference'
);
// 4. Violation test: Difference exceeds tolerance (e.g. flow 100.0 vs 105.0)
const wasmBad = {
...wasmSig,
links: {
P2: { ...wasmSig.links.P2, flow: 105.0 },
},
} as unknown as SimulationResult;
const resBad = computeComparison(serverSig, wasmBad);
assert.equal(resBad.passed, false, 'Violation beyond tolerance must fail');
assert.equal(resBad.toleranceViolations.length, 1, 'Should record exactly one violation');
assert.equal(resBad.toleranceViolations[0].variable, 'flow');
assert.equal(resBad.toleranceViolations[0].id, 'P2');
assert.equal(resBad.toleranceViolations[0].diff, 5.0);
// 5. NaN/Infinity detection test
const serverNaN = structuredClone(serverSig);
(serverNaN.links.P2 as any).flow = Number.NaN;
const resNaN = computeComparison(serverNaN, wasmSig);
assert.equal(resNaN.passed, false, 'Comparison must fail on NaN value');
assert.ok(resNaN.missingIds.some((id) => id.includes('NonFiniteValue:flow:P2')), 'Must record NonFiniteValue for NaN');
// 6. Missing timestamp or truncated time-series detection test
const serverShort = structuredClone(serverSig);
serverShort.timeSteps = [0, 3600];
(serverShort.links.P2 as any).timeSeries = {
flow: [100.0, 100.0],
velocity: [1.0, 1.0],
headloss: [0.1, 0.1],
};
const wasmTruncated = structuredClone(serverShort);
(wasmTruncated.links.P2 as any).timeSeries = {
flow: [100.0], // missing index 1 at 3600s
velocity: [1.0, 1.0],
headloss: [0.1, 0.1],
};
const resTrunc = computeComparison(serverShort, wasmTruncated);
assert.equal(resTrunc.passed, false, 'Truncated series missing index must fail');
assert.ok(resTrunc.missingIds.some((id) => id.includes('MissingValue:flow:P2@3600s')), 'Must record MissingValue for missing time-series element');
// 7. Unit metadata mismatch test
const wasmDiffUnits = structuredClone(serverSig);
wasmDiffUnits.units.flow = 'LPS';
const resUnitMismatch = computeComparison(serverSig, wasmDiffUnits);
assert.equal(resUnitMismatch.passed, false, 'Unit metadata mismatch must fail');
assert.ok(resUnitMismatch.missingIds.some((id) => id.includes('UnitMismatch:flow')), 'Must record UnitMismatch:flow');
});
test('23. GIS IMPORT & MULTILINESTRING: GeoJSON conversion with material roughness inference and real C DLL solution', () => {
// 1. Material roughness inference check
assert.equal(inferRoughnessFromMaterial('DIP (덕타일주철관)'), 110);
assert.equal(inferRoughnessFromMaterial('PE (폴리에틸렌관)'), 130);
assert.equal(inferRoughnessFromMaterial('PVC (염화비닐관)'), 140);
assert.equal(inferRoughnessFromMaterial('ST (강관)'), 100);
assert.equal(inferRoughnessFromMaterial('UNKNOWN', 120), 120);
// 2. Auto-detect fields check with standard Korean municipal GIS properties
const sampleProps = {
FTR_IDN: 1001,
PIP_DIA: 200,
PIP_LEN: 350.5,
PIP_MAT: 'DIP',
LAYER: '배수관',
};
const detected = autoDetectFields(sampleProps);
assert.equal(detected.pipeIdField, 'FTR_IDN');
assert.equal(detected.diameterField, 'PIP_DIA');
assert.equal(detected.lengthField, 'PIP_LEN');
assert.equal(detected.materialField, 'PIP_MAT');
// 3. MultiLineString and LineString conversion to EPANET model
const geojson = {
type: 'FeatureCollection',
features: [
{
type: 'Feature',
properties: { FTR_IDN: 'PIPE_MAIN', PIP_DIA: 300, PIP_MAT: 'DIP' },
geometry: {
type: 'LineString',
coordinates: [
[126.975, 37.565],
[126.978, 37.565],
],
},
},
{
// MultiLineString with 2 segments connected to the first line's endpoint
type: 'Feature',
properties: { FTR_IDN: 'PIPE_BRANCH', PIP_DIA: 150, PIP_MAT: 'PE' },
geometry: {
type: 'MultiLineString',
coordinates: [
[
[126.978, 37.565],
[126.98, 37.567],
],
[
[126.98, 37.567],
[126.982, 37.565],
],
],
},
},
],
};
const { model, summary } = buildNetworkFromGeoJSON(geojson as any, {
pipeIdField: 'FTR_IDN',
diameterField: 'PIP_DIA',
materialField: 'PIP_MAT',
defaultDiameter: 200,
defaultRoughness: 120,
sourceHead: 60,
});
// Both pipes had a real GIS diameter field, so neither should be flagged
// as needing review for an estimated diameter -- but roughness for both
// came from material inference (a guess, not a measured coefficient), so
// both must be flagged for review.
assert.equal(summary.defaultDiameterPipeCount, 0);
assert.equal(summary.defaultRoughnessPipeCount, summary.totalPipeCount);
assert.equal(summary.placeholderElevationCount, summary.totalNodeCount - 1);
// MultiLineString must be decomposed into PIPE_BRANCH_1 and PIPE_BRANCH_2
assert.ok(model.pipes['PIPE_MAIN'], 'Single LineString pipe must exist');
assert.ok(model.pipes['PIPE_BRANCH_1'], 'MultiLineString segment 1 must exist');
assert.ok(model.pipes['PIPE_BRANCH_2'], 'MultiLineString segment 2 must exist');
// Material-to-roughness inference check
assert.equal(model.pipes['PIPE_MAIN'].roughness, 110, 'DIP material must infer C=110');
assert.equal(model.pipes['PIPE_BRANCH_1'].roughness, 130, 'PE material must infer C=130');
// Reservoir check: must have created 1 Reservoir to act as water source
const reservoirs = Object.values(model.nodes).filter((n) => n.type === 'RESERVOIR');
assert.ok(reservoirs.length >= 1, 'At least one water source (Reservoir) must be created');
// Topology validation: network must be connected without errors
const issues = validateTopology(model);
const errors = issues.filter((i) => i.type === 'error');
assert.equal(errors.length, 0, `Imported network must have 0 topology errors; got: ${errors.map((e) => e.message).join(', ')}`);
// 4. Generate INP and execute inside the bundled EPANET 2.3.5 C DLL
const regen = generateInp(model);
assert.ok(regen.includes('[PIPES]'), 'Regenerated INP must contain [PIPES]');
assert.ok(regen.trim().endsWith('[END]'), 'Regenerated INP must terminate with [END]');
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'spipe_geojson_'));
try {
const inpPath = path.join(tmpDir, 'gis_imported.inp');
const rptPath = path.join(tmpDir, 'gis_imported.rpt');
const outPath = path.join(tmpDir, 'gis_imported.out');
fs.writeFileSync(inpPath, regen);
const pythonExe = path.resolve('.venv/Scripts/python.exe');
const pyFile = path.join(tmpDir, 'runner.py');
fs.writeFileSync(
pyFile,
`import ctypes, os, sys
lib = ctypes.CDLL(os.path.abspath('64bit/epanet2.dll'))
ph = ctypes.c_void_p()
def check(rc, step):
if rc != 0:
sys.stderr.write(f'FAILED at {step}: rc={rc}\\n')
sys.exit(1)
check(lib.EN_createproject(ctypes.byref(ph)), 'createproject')
check(lib.EN_open(ph, sys.argv[1].encode('utf-8'), sys.argv[2].encode('utf-8'), sys.argv[3].encode('utf-8')), 'open')
check(lib.EN_openH(ph), 'openH')
check(lib.EN_initH(ph, 0), 'initH')
t = ctypes.c_long()
check(lib.EN_runH(ph, ctypes.byref(t)), 'runH')
check(lib.EN_closeH(ph), 'closeH')
check(lib.EN_close(ph), 'close')
check(lib.EN_deleteproject(ph), 'deleteproject')
print('EPANET_OPEN_SOLVE_OK')
`
);
const pythonCmd = `"${pythonExe}" "${pyFile}" "${inpPath}" "${rptPath}" "${outPath}"`;
const stdout = execSync(pythonCmd, { encoding: 'utf-8' });
assert.ok(
stdout.includes('EPANET_OPEN_SOLVE_OK'),
'Imported GeoJSON network must solve in EPANET 2.3.5 C DLL with rc=0'
);
} finally {
fs.rmSync(tmpDir, { recursive: true, force: true });
}
});
test('24. WATER QUALITY SIMULATION: execute Chlorine, Fluoride and Source Trace in EPANET 2.3.5 C DLL', () => {
// Verifies that the full water quality pipeline runs with rc=0 across all three official networks:
// Net1 (Chlorine decay, 24h), Net2 (Fluoride calibration, 55h), Net3 (Lake Source Tracing, 24h)
const networks = [
{ name: 'Net1', path: 'public/Net1.inp', expectedType: 1, expectedChem: 'Chlorine', expectedUnits: 'mg/L' },
{ name: 'Net2', path: 'public/Net2.inp', expectedType: 1, expectedChem: 'Fluoride', expectedUnits: 'mg/L' },
{ name: 'Net3', path: 'public/Net3.inp', expectedType: 3, expectedChem: 'TRACE', expectedUnits: '% from' },
];
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'spipe_qual_'));
try {
for (const net of networks) {
const pythonExe = path.resolve('.venv/Scripts/python.exe');
const pyFile = path.join(tmpDir, `${net.name}_qual.py`);
const rptPath = path.join(tmpDir, `${net.name}.rpt`);
const outPath = path.join(tmpDir, `${net.name}.out`);
const jsonPath = path.join(tmpDir, `${net.name}_res.json`);
fs.writeFileSync(
pyFile,
`import ctypes, os, sys, json
lib = ctypes.CDLL(os.path.abspath('64bit/epanet2.dll'))
ph = ctypes.c_void_p()
def check(rc, step):
if rc != 0:
sys.stderr.write(f'FAILED at {step}: rc={rc}\\n')
sys.exit(1)
check(lib.EN_createproject(ctypes.byref(ph)), 'createproject')
check(lib.EN_open(ph, sys.argv[1].encode('utf-8'), sys.argv[2].encode('utf-8'), sys.argv[3].encode('utf-8')), 'open')
qual_type = ctypes.c_int()
trace_node = ctypes.c_int()
chem_name = ctypes.create_string_buffer(256)
chem_units = ctypes.create_string_buffer(256)
check(lib.EN_getqualinfo(ph, ctypes.byref(qual_type), chem_name, chem_units, ctypes.byref(trace_node)), 'getqualinfo')
# 1. Run hydraulics and save for quality
check(lib.EN_openH(ph), 'openH')
check(lib.EN_initH(ph, 1), 'initH')
t = ctypes.c_long()
tstep = ctypes.c_long(1)
while tstep.value > 0:
check(lib.EN_runH(ph, ctypes.byref(t)), 'runH')
check(lib.EN_nextH(ph, ctypes.byref(tstep)), 'nextH')
check(lib.EN_closeH(ph), 'closeH')
# 2. Run water quality simulation
check(lib.EN_openQ(ph), 'openQ')
check(lib.EN_initQ(ph, 0), 'initQ')
tQ = ctypes.c_long()
tstepQ = ctypes.c_long(1)
node_count = ctypes.c_int()
check(lib.EN_getcount(ph, 0, ctypes.byref(node_count)), 'getcount')
quality_steps = []
while tstepQ.value > 0:
check(lib.EN_runQ(ph, ctypes.byref(tQ)), 'runQ')
qv = ctypes.c_double()
check(lib.EN_getnodevalue(ph, 1, 12, ctypes.byref(qv)), 'getnodevalue_qual')
quality_steps.append({'time': tQ.value, 'quality': qv.value})
check(lib.EN_nextQ(ph, ctypes.byref(tstepQ)), 'nextQ')
check(lib.EN_closeQ(ph), 'closeQ')
check(lib.EN_close(ph), 'close')
check(lib.EN_deleteproject(ph), 'deleteproject')
with open(sys.argv[4], 'w') as f:
json.dump({
'qualType': qual_type.value,
'chemName': chem_name.value.decode('utf-8', errors='ignore').strip(),
'chemUnits': chem_units.value.decode('utf-8', errors='ignore').strip(),
'steps': len(quality_steps),
'firstQual': quality_steps[0]['quality'] if quality_steps else 0,
}, f)
print('EPANET_QUALITY_OK')
`
);
const pythonCmd = `"${pythonExe}" "${pyFile}" "${path.resolve(net.path)}" "${rptPath}" "${outPath}" "${jsonPath}"`;
const stdout = execSync(pythonCmd, { encoding: 'utf-8' });
assert.ok(stdout.includes('EPANET_QUALITY_OK'), `${net.name}: Water quality run must succeed with rc=0`);
const parsed = JSON.parse(fs.readFileSync(jsonPath, 'utf-8'));
assert.equal(parsed.qualType, net.expectedType, `${net.name}: Quality type must match expected`);
assert.equal(parsed.chemName, net.expectedChem, `${net.name}: Chemical name must match expected`);
assert.equal(parsed.chemUnits, net.expectedUnits, `${net.name}: Chemical units must match expected`);
assert.ok(parsed.steps >= 2, `${net.name}: Quality simulation must produce multiple time steps`);
assert.ok(Number.isFinite(parsed.firstQual), `${net.name}: Initial quality must be finite`);
}
} finally {
fs.rmSync(tmpDir, { recursive: true, force: true });
}
});
test('25. PUMP ENERGY & POWER ANALYSIS: compute kWh, peak kW, and efficiency in EPANET 2.3.5 C DLL', () => {
// Verifies real-time power (kW), total energy (kWh), and efficiency (%) calculations
// on pumps in Net1 (single pump) using actual variable time-step intervals.
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'spipe_energy_'));
try {
const pythonExe = path.resolve('.venv/Scripts/python.exe');
const pyFile = path.join(tmpDir, 'energy_runner.py');
const jsonPath = path.join(tmpDir, 'energy_res.json');
const rptPath = path.join(tmpDir, 'net1_e.rpt');
const outPath = path.join(tmpDir, 'net1_e.out');
const inpPath = path.resolve('public/Net1.inp');
fs.writeFileSync(
pyFile,
`import ctypes, os, sys, json
lib = ctypes.CDLL(os.path.abspath('64bit/epanet2.dll'))
ph = ctypes.c_void_p()
def check(rc, step):
if rc != 0:
sys.stderr.write(f'FAILED at {step}: rc={rc}\\n')
sys.exit(1)
check(lib.EN_createproject(ctypes.byref(ph)), 'createproject')
check(lib.EN_open(ph, sys.argv[1].encode('utf-8'), sys.argv[2].encode('utf-8'), sys.argv[3].encode('utf-8')), 'open_net1')
link_count = ctypes.c_int()
check(lib.EN_getcount(ph, 2, ctypes.byref(link_count)), 'getcount')
pump_indices = []
for i in range(1, link_count.value + 1):
ltype = ctypes.c_int()
check(lib.EN_getlinktype(ph, i, ctypes.byref(ltype)), 'getlinktype')
if ltype.value == 2: # EN_PUMP
lid = ctypes.create_string_buffer(256)
check(lib.EN_getlinkid(ph, i, lid), 'getlinkid')
pump_indices.append((i, lid.value.decode()))
check(lib.EN_openH(ph), 'openH')
check(lib.EN_initH(ph, 0), 'initH')
t = ctypes.c_long()
tstep = ctypes.c_long(1)
readings = []
val_energy = ctypes.c_double()
val_effic = ctypes.c_double()
while tstep.value > 0:
check(lib.EN_runH(ph, ctypes.byref(t)), 'runH')
p_idx = pump_indices[0][0]
check(lib.EN_getlinkvalue(ph, p_idx, 13, ctypes.byref(val_energy)), 'get_energy')
check(lib.EN_getlinkvalue(ph, p_idx, 17, ctypes.byref(val_effic)), 'get_effic')
readings.append({'time': t.value, 'kw': val_energy.value, 'effic': val_effic.value})
check(lib.EN_nextH(ph, ctypes.byref(tstep)), 'nextH')
check(lib.EN_closeH(ph), 'closeH')
check(lib.EN_close(ph), 'close')
check(lib.EN_deleteproject(ph), 'deleteproject')
total_kwh = sum(
readings[i]['kw'] * (readings[i + 1]['time'] - readings[i]['time']) / 3600.0
for i in range(len(readings) - 1)
)
peak_kw = max(r['kw'] for r in readings)
active_effics = [r['effic'] for r in readings if r['effic'] > 0]
avg_effic = sum(active_effics) / len(active_effics) if active_effics else 0
active_sec = sum(
(readings[i + 1]['time'] - readings[i]['time'])
for i in range(len(readings) - 1)
if readings[i]['kw'] > 0
)
total_sec = readings[-1]['time'] - readings[0]['time']
utilization = (active_sec / total_sec) * 100.0 if total_sec > 0 else 0.0
with open(sys.argv[4], 'w') as f:
json.dump({
'pumpId': pump_indices[0][1],
'steps': len(readings),
'totalKwh': round(total_kwh, 2),
'peakKw': round(peak_kw, 2),
'avgEfficiency': round(avg_effic * 100, 1),
'utilization': round(utilization, 1),
}, f)
print('EPANET_ENERGY_OK')
`
);
const pythonCmd = `"${pythonExe}" "${pyFile}" "${inpPath}" "${rptPath}" "${outPath}" "${jsonPath}"`;
const stdout = execSync(pythonCmd, { encoding: 'utf-8' });
assert.ok(stdout.includes('EPANET_ENERGY_OK'), 'Pump energy calculation in C DLL must succeed with rc=0');
const res = JSON.parse(fs.readFileSync(jsonPath, 'utf-8'));
assert.equal(res.pumpId, '9', 'Net1 pump id must be 9');
assert.equal(res.steps, 27, 'Net1 must produce 27 EPS energy steps');
// True interval-integrated kWh of Net1 pump 9 is ~1333 kWh, not ~1538 kWh
assert.ok(res.totalKwh > 1300 && res.totalKwh < 1360, `Net1 pump interval-integrated energy should be ~1333 kWh, got ${res.totalKwh}`);
assert.ok(res.peakKw > 90 && res.peakKw < 110, `Net1 pump peak power should be ~96.7 kW, got ${res.peakKw}`);
assert.equal(res.avgEfficiency, 75.0, 'Net1 pump operating efficiency must be 75.0%');
assert.ok(res.utilization > 50 && res.utilization < 65, `Net1 pump utilization should be ~57.7%, got ${res.utilization}%`);
} finally {
fs.rmSync(tmpDir, { recursive: true, force: true });
}
});
test('26. BACKEND RUN_EPANET INTEGRATION: Net1 & Net3 pump energy integration, simultaneous peak, and returned series match', () => {
const pythonExe = path.resolve('.venv/Scripts/python.exe');
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'spipe_be_energy_'));
try {
const pyFile = path.join(tmpDir, 'test_be_energy.py');
fs.writeFileSync(
pyFile,
`import json, os, pathlib, sys
root = pathlib.Path(r'${path.resolve('.').replace(/\\/g, '/')}')
sys.path.insert(0, str(root))
from backend.main import run_epanet
tmp = pathlib.Path(r'${tmpDir.replace(/\\/g, '/')}')
tmp = pathlib.Path(r'${tmpDir.replace(/\\/g, '/')}')
# Net1
r1 = run_epanet(str(root / 'public/Net1.inp'), str(tmp / 'net1.rpt'), str(tmp / 'net1.out'))
ts1 = r1['timeSteps']
p9 = r1['energySummary']['pumps']['9']
s9 = r1['links']['9']['timeSeries']['energy']
reintegrated1 = round(sum(s9[i] * (ts1[i + 1] - ts1[i]) / 3600.0 for i in range(len(ts1) - 1)), 2)
# Net3
r3 = run_epanet(str(root / 'public/Net3.inp'), str(tmp / 'net3.rpt'), str(tmp / 'net3.out'))
ts3 = r3['timeSteps']
pumps3 = r3['energySummary']['pumps']
simul_peak3 = max(
sum(r3['links'][pid]['timeSeries']['energy'][i] for pid in pumps3)
for i in range(len(ts3))
)
print(json.dumps({
'net1_totalKwh': p9['totalKwh'],
'net1_reintegrated': reintegrated1,
'net3_peakKw': r3['energySummary']['peakKw'],
'net3_simultaneousPeak': round(simul_peak3, 2),
}))
`
);
const out = execSync(`"${pythonExe}" "${pyFile}"`, { encoding: 'utf-8' });
const parsed = JSON.parse(out.trim());
assert.equal(parsed.net1_totalKwh, parsed.net1_reintegrated, 'Net1 totalKwh must strictly match time-interval reintegrated series');
assert.equal(parsed.net3_peakKw, parsed.net3_simultaneousPeak, 'Net3 peakKw must strictly match simultaneous multi-pump peak sum');
} finally {
fs.rmSync(tmpDir, { recursive: true, force: true });
}
});
test('27. WATER QUALITY ERROR HANDLING: failed EN_runQ must flag status="failed" and not mask failure with zeros', () => {
const pythonExe = path.resolve('.venv/Scripts/python.exe');
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'spipe_be_qual_'));
try {
const pyFile = path.join(tmpDir, 'test_be_qual.py');
fs.writeFileSync(
pyFile,
`import json, os, pathlib, sys
root = pathlib.Path(r'${path.resolve('.').replace(/\\/g, '/')}')
sys.path.insert(0, str(root))
from backend.main import run_epanet, api
tmp = pathlib.Path(r'${tmpDir.replace(/\\/g, '/')}')
tmp = pathlib.Path(r'${tmpDir.replace(/\\/g, '/')}')
original_runQ = api.lib.EN_runQ
def failing_runQ(*args):
raise RuntimeError('injected quality solver error')
api.lib.EN_runQ = failing_runQ
try:
res = run_epanet(str(root / 'public/Net1.inp'), str(tmp / 'net1_q.rpt'), str(tmp / 'net1_q.out'))
qinfo = res['qualityInfo']
# Nodes must not have fake zero arrays
all_quality_empty = all(len(n['timeSeries']['quality']) == 0 for n in res['nodes'].values())
all_quality_val_none = all(n['quality'] is None for n in res['nodes'].values())
print(json.dumps({
'status': qinfo.get('status'),
'hasErrorMessage': bool(qinfo.get('errorMessage')),
'allQualityEmpty': all_quality_empty,
'allQualityValNone': all_quality_val_none,
}))
finally:
api.lib.EN_runQ = original_runQ
`
);
const out = execSync(`"${pythonExe}" "${pyFile}"`, { encoding: 'utf-8' });
const parsed = JSON.parse(out.trim());
assert.equal(parsed.status, 'failed', 'qualityInfo.status must be "failed" when EN_runQ throws');
assert.equal(parsed.hasErrorMessage, true, 'qualityInfo must record errorMessage');
assert.equal(parsed.allQualityEmpty, true, 'Node quality series must remain empty, never zero-filled on failure');
assert.equal(parsed.allQualityValNone, true, 'Node quality scalar must be null on failure');
} finally {
fs.rmSync(tmpDir, { recursive: true, force: true });
}
});
test('28. UNIT CONVERSION SAFETY: FCV valve with numeric control on flow scale change must be blocked', () => {
const sampleInp = `[TITLE]
FCV Control Test
[JUNCTIONS]
J1 10 1 ;
J2 10 1 ;
[RESERVOIRS]
R1 50 ;
[PIPES]
P1 R1 J1 100 200 100 0 Open ;
[VALVES]
V1 J1 J2 100 FCV 10 0 ;
[CONTROLS]
LINK V1 10 AT TIME 2
[OPTIONS]
UNITS LPS
[END]
`;
const model = parseInp(sampleInp);
// Converting LPS -> LPM (same SI system, but flow multiplier is 60)
const check = checkUnitConversion(model, 'LPM');
assert.equal(
check.canConvert,
false,
'Conversion must be blocked when unit-dependent numeric control setting exists on flow-scale change'
);
assert.ok(
(check.reason || '').includes('V1'),
`Blocking reason must mention the affected link: ${check.reason}`
);
});
test('29. UNIT CONVERSION SAFETY: PRV valve with numeric control across system switch must be blocked', () => {
const sampleInp = `[TITLE]
PRV Control Test
[JUNCTIONS]
J1 10 1 ;
J2 10 1 ;
[RESERVOIRS]
R1 50 ;
[PIPES]
P1 R1 J1 100 200 100 0 Open ;
[VALVES]
V1 J1 J2 100 PRV 50 0 ;
[CONTROLS]
LINK V1 40 AT TIME 2
[OPTIONS]
UNITS GPM
[END]
`;
const model = parseInp(sampleInp);
const check = checkUnitConversion(model, 'LPS');
assert.equal(check.canConvert, false, 'Numeric control on PRV must block conversion across system switch');
});
test('30. ATTRIBUTE TABLE: validateSingleField rejects invalid numbers/status and accepts valid edits', () => {
const sampleInp = `[TITLE]
Attr Table Validation Test
[JUNCTIONS]
J1 10.5 25.0 ;
[RESERVOIRS]
R1 50.0 ;
[PIPES]
P1 R1 J1 150.0 200.0 120 0.5 Open ;
[OPTIONS]
UNITS LPS
[END]
`;
const model = parseInp(sampleInp);
// 1. Junction elevation validation
const validElev = validateSingleField('junction', 'elevation', '15.75', 'J1', model);
assert.equal(validElev.valid, true);
assert.equal(validElev.parsedValue, 15.75);
const invalidElev = validateSingleField('junction', 'elevation', 'not-a-number', 'J1', model);
assert.equal(invalidElev.valid, false);
assert.ok(invalidElev.error?.includes('숫자'));
// 2. Pipe length/diameter validation
const validLen = validateSingleField('pipe', 'length', '250.5', 'P1', model);
assert.equal(validLen.valid, true);
assert.equal(validLen.parsedValue, 250.5);
const zeroLen = validateSingleField('pipe', 'length', '0', 'P1', model);
assert.equal(zeroLen.valid, false);
assert.ok(zeroLen.error?.includes('0보다 큰 숫자'));
const negDia = validateSingleField('pipe', 'diameter', '-50', 'P1', model);
assert.equal(negDia.valid, false);
// 3. Pipe status validation
const validStatus = validateSingleField('pipe', 'status', 'closed', 'P1', model);
assert.equal(validStatus.valid, true);
assert.equal(validStatus.parsedValue, 'Closed');
const invalidStatus = validateSingleField('pipe', 'status', 'BROKEN', 'P1', model);
assert.equal(invalidStatus.valid, false);
// 4. Node self-loop validation
const selfLoop = validateSingleField('pipe', 'node2', 'R1', 'P1', model);
assert.equal(selfLoop.valid, false);
assert.ok(selfLoop.error?.includes('자기순환 불가'));
});
test('31. ATTRIBUTE TABLE TOPOLOGY: renameNode & renamePipe update connected links, controls, and reject duplicates', () => {
const sampleInp = `[TITLE]
Rename Test
[JUNCTIONS]
J1 10.0 5.0 ;
J2 12.0 8.0 ;
[RESERVOIRS]
R1 50.0 ;
[PIPES]
P1 R1 J1 100 200 100 0 Open ;
P2 J1 J2 150 150 100 0 Open ;
[CONTROLS]
LINK P1 OPEN IF NODE J1 BELOW 15
[OPTIONS]
UNITS LPS
[END]
`;
const model = parseInp(sampleInp);
// 1. Rename J1 -> J_MAIN
const renamedModel = renameNode(model, 'J1', 'J_MAIN');
assert.equal(renamedModel.nodes['J1'], undefined);
assert.ok(renamedModel.nodes['J_MAIN']);
assert.equal(renamedModel.nodes['J_MAIN'].elevation, 10.0);
// Check that connected pipes were updated
assert.equal(renamedModel.pipes['P1'].node2, 'J_MAIN');
assert.equal(renamedModel.pipes['P2'].node1, 'J_MAIN');
assert.equal(renamedModel.pipes['P2'].node2, 'J2');
// Check that control reference was updated
assert.equal(renamedModel.controls[0].nodeId, 'J_MAIN');
assert.ok(renamedModel.controls[0].rawText.includes('NODE J_MAIN'));
// 2. Reject duplicate node rename
assert.throws(() => renameNode(model, 'J1', 'J2'), /이미 존재하는/);
// 3. Rename P2 -> P_FEED
const renamedPipeModel = renamePipe(renamedModel, 'P2', 'P_FEED');
assert.equal(renamedPipeModel.pipes['P2'], undefined);
assert.ok(renamedPipeModel.pipes['P_FEED']);
assert.equal(renamedPipeModel.pipes['P_FEED'].node1, 'J_MAIN');
assert.equal(renamedPipeModel.pipes['P_FEED'].node2, 'J2');
// 4. Reject duplicate pipe rename
assert.throws(() => renamePipe(model, 'P1', 'P2'), /이미 존재하는/);
});
test('32. ATTRIBUTE TABLE INP REGENERATION & SOLVE: table edits propagate to generateInp text and solve in EPANET DLL', () => {
const sampleInp = `[TITLE]
Table Edit Regeneration Test
[JUNCTIONS]
J1 10.0 5.0 ;
[RESERVOIRS]
R1 50.0 ;
[PIPES]
P1 R1 J1 100.0 200.0 100 0 Open ;
[COORDINATES]
J1 127.123456 37.654321
R1 127.0 37.5
[OPTIONS]
UNITS LPS
[END]
`;
const model = parseInp(sampleInp);
// Apply table edits: Elevation 10 -> 22.5, Demand 5 -> 17.8, Coordinates, Pipe Length 100 -> 345.6
let edited = updateNodeAttributes(model, 'J1', {
elevation: 22.5,
demand: 17.8,
x: 127.987654,
y: 37.112233,
});
edited = updatePipeAttributes(edited, 'P1', {
length: 345.6,
diameter: 250.0,
roughness: 130,
});
const regen = generateInp(edited);
// Verify that regenerated text reflects all edits
assert.ok(regen.includes('22.5'), 'Regenerated INP must contain edited elevation 22.5');
assert.ok(regen.includes('17.8'), 'Regenerated INP must contain edited demand 17.8');
assert.ok(regen.includes('345.6'), 'Regenerated INP must contain edited pipe length 345.6');
assert.ok(regen.includes('250'), 'Regenerated INP must contain edited pipe diameter 250');
assert.ok(regen.includes('127.987654'), 'Regenerated INP must contain edited X coordinate');
assert.ok(regen.includes('37.112233'), 'Regenerated INP must contain edited Y coordinate');
// Test solving in C DLL
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'spipe_table_edit_'));
try {
const inpPath = path.join(tmpDir, 'table_edited.inp');
const rptPath = path.join(tmpDir, 'table_edited.rpt');
const outPath = path.join(tmpDir, 'table_edited.out');
fs.writeFileSync(inpPath, regen);
const pythonExe = path.resolve('.venv/Scripts/python.exe');
const pyFile = path.join(tmpDir, 'runner.py');
fs.writeFileSync(
pyFile,
`import ctypes, os, sys
lib = ctypes.CDLL(os.path.abspath('64bit/epanet2.dll'))
ph = ctypes.c_void_p()
def check(rc, step):
if rc != 0:
sys.stderr.write(f'FAILED at {step}: rc={rc}\\n')
sys.exit(1)
check(lib.EN_createproject(ctypes.byref(ph)), 'createproject')
check(lib.EN_open(ph, sys.argv[1].encode('utf-8'), sys.argv[2].encode('utf-8'), sys.argv[3].encode('utf-8')), 'open')
check(lib.EN_openH(ph), 'openH')
check(lib.EN_initH(ph, 0), 'initH')
t = ctypes.c_long()
check(lib.EN_runH(ph, ctypes.byref(t)), 'runH')
check(lib.EN_closeH(ph), 'closeH')
check(lib.EN_close(ph), 'close')
check(lib.EN_deleteproject(ph), 'deleteproject')
print('EPANET_TABLE_EDIT_OK')
`
);
const stdout = execSync(`"${pythonExe}" "${pyFile}" "${inpPath}" "${rptPath}" "${outPath}"`, {
encoding: 'utf-8',
});
assert.ok(stdout.includes('EPANET_TABLE_EDIT_OK'), 'Table-edited model must solve cleanly in EPANET DLL');
} finally {
fs.rmSync(tmpDir, { recursive: true, force: true });
}
});
test('33. GIS LAYERS: parseGeoJsonString validates features, detects geometry types, and estimates CRS', () => {
// 1. WGS84 GeoJSON
const wgs84Json = JSON.stringify({
type: 'FeatureCollection',
features: [
{
type: 'Feature',
properties: { name: 'Node A', pipe_dia: 200 },
geometry: { type: 'Point', coordinates: [127.0286, 37.4981] },
},
{
type: 'Feature',
properties: { name: 'Pipe 1', length: 150 },
geometry: {
type: 'LineString',
coordinates: [
[127.0286, 37.4981],
[127.0312, 37.5005],
],
},
},
],
});
const layerWgs = parseGeoJsonString(wgs84Json, 'water_network.geojson');
assert.equal(layerWgs.name, 'water_network');
assert.equal(layerWgs.featureCount, 2);
assert.ok(layerWgs.geomTypes.includes('Point'));
assert.ok(layerWgs.geomTypes.includes('LineString'));
assert.equal(layerWgs.estimatedCrs, 'WGS84 (EPSG:4326)');
assert.equal(layerWgs.visible, true);
assert.ok(layerWgs.opacity > 0);
// 2. Korean UTM-K (EPSG:5179) GeoJSON
const utmkJson = JSON.stringify({
type: 'FeatureCollection',
features: [
{
type: 'Feature',
properties: { FID: 1, PIP_ID: 'P_01' },
geometry: {
type: 'LineString',
coordinates: [
[960500, 1952000],
[961000, 1952500],
],
},
},
],
});
const layerUtmk = parseGeoJsonString(utmkJson, 'suwon_pipes.geojson');
assert.equal(layerUtmk.estimatedCrs, '한국 UTM-K (EPSG:5179)');
// Normalized coordinates must be in WGS84 range (roughly 126~128 lon, 37~38 lat)
const firstCoord = (layerUtmk.featureCollection.features[0].geometry as any).coordinates[0];
assert.ok(firstCoord[0] > 126 && firstCoord[0] < 129, `Longitude ${firstCoord[0]} must be in WGS84 range`);
assert.ok(firstCoord[1] > 36 && firstCoord[1] < 39, `Latitude ${firstCoord[1]} must be in WGS84 range`);
// 3. Error handling: invalid JSON
assert.throws(() => {
parseGeoJsonString('{ invalid json', 'bad.json');
}, /JSON 구문 분석 오류/);
// 4. Error handling: empty features
assert.throws(() => {
parseGeoJsonString(JSON.stringify({ type: 'FeatureCollection', features: [] }), 'empty.json');
}, /공간 객체\(features\)가 없습니다/);
});
test('34. GIS EXTENTS: computeGeoJsonExtents accurately calculates bounding box across point, line, and polygon', () => {
const multiGeomJson = {
type: 'FeatureCollection' as const,
features: [
{
type: 'Feature' as const,
properties: {},
geometry: { type: 'Point' as const, coordinates: [10, 20] },
},
{
type: 'Feature' as const,
properties: {},
geometry: {
type: 'LineString' as const,
coordinates: [
[5, 15],
[25, 35],
],
},
},
{
type: 'Feature' as const,
properties: {},
geometry: {
type: 'Polygon' as const,
coordinates: [
[
[0, 5],
[30, 5],
[30, 40],
[0, 40],
[0, 5],
],
],
},
},
],
};
const extents = computeGeoJsonExtents(multiGeomJson);
assert.ok(extents !== null);
assert.equal(extents.minX, 0);
assert.equal(extents.maxX, 30);
assert.equal(extents.minY, 5);
assert.equal(extents.maxY, 40);
});
test('35. NETWORK CLIPBOARD: dual TSV/JSON payload, topological connectivity check, collision avoidance, and offset paste', () => {
const sampleInp = `[TITLE]
Clipboard Test
[JUNCTIONS]
J1 50 0 ;
J2 45 10 ;
[PIPES]
P1 J1 J2 100 200 100 0 Open ;
[COORDINATES]
J1 10 20
J2 30 40
[END]
`;
const model = parseInp(sampleInp);
// 1. Create payload with J1 and P1 selected
const payloadResult = createNetworkClipboardPayload(model, { type: 'link', id: 'P1' }, {
nodes: new Set(['J1', 'J2']),
links: new Set(['P1']),
gisFeatures: [],
});
assert.ok(payloadResult !== null);
assert.equal(payloadResult.json.source, 'GISPipe');
assert.equal(payloadResult.json.version, 1);
assert.equal(payloadResult.json.nodes.length, 2);
assert.equal(payloadResult.json.pipes.length, 1);
assert.ok(payloadResult.tsv.includes('J1\t10\t20\t50'));
assert.ok(payloadResult.tsv.includes('P1\tJ1\tJ2\t200\t100'));
// 2. Validate and prepare paste into the same model (triggers ID collision rename + offset)
const pastePrep = validateAndPreparePaste(payloadResult.json, model, { dx: 15, dy: 25 });
assert.equal(pastePrep.valid, true);
assert.equal(pastePrep.nodesToInsert.length, 2);
assert.equal(pastePrep.pipesToInsert.length, 1);
// IDs must have collided and been renamed with _copy
assert.ok(pastePrep.nodesToInsert.some((n) => n.id === 'J1_copy' && n.x === 25 && n.y === 45));
assert.ok(pastePrep.nodesToInsert.some((n) => n.id === 'J2_copy' && n.x === 45 && n.y === 65));
const pastedPipe = pastePrep.pipesToInsert[0];
assert.equal(pastedPipe.id, 'P1_copy');
assert.equal(pastedPipe.node1, 'J1_copy');
assert.equal(pastedPipe.node2, 'J2_copy');
// 3. Merging into model
const updatedModel = applyPasteToModel(model, pastePrep);
assert.ok(updatedModel.nodes['J1_copy']);
assert.ok(updatedModel.nodes['J2_copy']);
assert.ok(updatedModel.pipes['P1_copy']);
assert.equal(Object.keys(updatedModel.nodes).length, 4);
assert.equal(Object.keys(updatedModel.pipes).length, 2);
// 4. Connectivity safety check: copying a pipe ALONE without connected nodes must be BLOCKED
const orphanPipePayload = {
source: 'GISPipe',
version: 1,
kind: 'network-selection',
units: 'GPM',
nodes: [],
pipes: [{ id: 'P_ORPHAN', node1: 'GHOST_NODE_1', node2: 'GHOST_NODE_2', length: 100, diameter: 200, roughness: 100, status: 'Open' }],
pumps: [],
valves: [],
tanks: [],
reservoirs: [],
};
const orphanCheck = validateAndPreparePaste(orphanPipePayload, model);
assert.equal(orphanCheck.valid, false);
assert.ok(orphanCheck.error?.includes('연결 절점'));
// 5. Foreign / invalid JSON must be rejected
const badJsonCheck = validateAndPreparePaste({ foo: 'bar' }, model);
assert.equal(badJsonCheck.valid, false);
});
test('36. SHAPEFILE PARSER: parseShpBinary extracts Point and Polyline records without third-party packages', () => {
// Synthesize minimal valid Point Shapefile binary buffer (100-byte header + 1 Point record)
const buffer = new ArrayBuffer(100 + 28);
const view = new DataView(buffer);
// Header
view.setInt32(0, 9994, false); // File code
view.setInt32(24, (100 + 28) / 2, false); // File length in 16-bit words
view.setInt32(28, 1000, true); // Version
view.setInt32(32, 1, true); // ShapeType: Point (1)
// Record 1 (8-byte record header + 20-byte point shape)
view.setInt32(100, 1, false); // Record number
view.setInt32(104, 10, false); // Content length in 16-bit words (20 bytes / 2 = 10)
view.setInt32(108, 1, true); // ShapeType: Point
view.setFloat64(112, 127.05, true); // X (lon)
view.setFloat64(120, 37.55, true); // Y (lat)
const parsed = parseShpBinary(new Uint8Array(buffer), [{ NAME: 'Point A' }]);
assert.equal(parsed.features.length, 1);
assert.equal(parsed.features[0].geometry.type, 'Point');
const coords = (parsed.features[0].geometry as any).coordinates;
assert.equal(coords[0], 127.05);
assert.equal(coords[1], 37.55);
assert.equal(parsed.features[0].properties?.NAME, 'Point A');
});
test('37. PIPE METADATA: reactions, tag, description, and reversed orientation survive INP round-trip', () => {
const source = `[JUNCTIONS]
J1 10 0
J2 20 0
[PIPES]
P1 J1 J2 100 200 110 0 Open ; 기존 설명
[TAGS]
LINK P1 기존태그
[REACTIONS]
ORDER BULK 1
GLOBAL BULK -0.5
BULK P1 -0.7
WALL P1 -1.2
[CONTROLS]
LINK P1 CLOSED AT TIME 4
[VERTICES]
P1 10 10
[OPTIONS]
UNITS LPS
HEADLOSS H-W
[TIMES]
DURATION 24:00
[END]`;
const parsed = parseInp(source);
assert.equal(parsed.pipes.P1.bulkCoeff, -0.7);
assert.equal(parsed.pipes.P1.wallCoeff, -1.2);
assert.equal(parsed.pipes.P1.tag, '기존태그');
assert.equal(parsed.pipes.P1.description, '기존 설명');
const edited = updatePipeAttributes(reversePipeDirection(parsed, 'P1'), 'P1', {
bulkCoeff: -0.8,
wallCoeff: -1.4,
tag: '갱신태그',
description: '갱신 설명',
});
const generated = generateInp(edited);
const reparsed = parseInp(generated);
assert.equal(reparsed.pipes.P1.node1, 'J2');
assert.equal(reparsed.pipes.P1.node2, 'J1');
assert.equal(reparsed.pipes.P1.bulkCoeff, -0.8);
assert.equal(reparsed.pipes.P1.wallCoeff, -1.4);
assert.equal(reparsed.pipes.P1.tag, '갱신태그');
assert.equal(reparsed.pipes.P1.description, '갱신 설명');
assert.match(generated, /LINK P1 CLOSED AT TIME 4/);
assert.match(generated, /P1 10 10/);
assert.match(generated, /GLOBAL BULK\s+-0\.5/);
});
test('38. KOREAN DISPLAY UNITS: model values convert without mutating source units', () => {
const daily = flowToM3Day(1, 'LPS');
assert.equal(daily, 86.4);
assert.ok(Math.abs(m3DayToFlow(daily, 'LPS') - 1) < 1e-12);
assert.ok(Math.abs(flowToM3Day(1, 'GPM') - 5.450992) < 0.00001);
// pressureToMeters takes the engine's actual reported pressure unit
// (psi/kPa/m/bar/ft), never a flow unit -- see resolvePressureUnit for the
// flow-unit-based fallback used only before any result exists.
assert.ok(Math.abs(pressureToMeters(1, 'psi') - 0.7034387) < 0.00001);
assert.equal(diameterToMillimeters(1, 'GPM'), 25.4);
});
test('39. INP ENCODING: invalid UTF-8 Korean bytes fall back to CP949', () => {
const prefix = Array.from(Buffer.from('[TITLE]\\r\\n', 'ascii'));
const suffix = Array.from(Buffer.from('\\r\\n[END]\\r\\n', 'ascii'));
const bytes = Uint8Array.from([...prefix, 0xc7, 0xd1, 0xb1, 0xdb, ...suffix]);
const decoded = decodeInpBytes(bytes.buffer);
assert.equal(decoded.encoding, 'cp949');
assert.match(decoded.text, /한글/);
assert.match(decoded.warning || '', /CP949/);
});
test('40. MODEL SETTINGS: quality and time options persist through update and regeneration', () => {
const source = `[JUNCTIONS]
J1 10 0
[OPTIONS]
UNITS LPS
QUALITY NONE
[TIMES]
DURATION 24:00
HYDRAULIC TIMESTEP 1:00
PATTERN START 0:00
REPORT START 0:00
STATISTIC NONE
[END]`;
const parsed = parseInp(source);
const qualityEntries = parsed.options.rawEntries.map((entry) =>
entry.key.toUpperCase() === 'QUALITY' ? { ...entry, value: 'AGE' } : entry
);
const timeEntries = parsed.options.timeEntries.map((entry) => {
const key = entry.key.toUpperCase();
if (key === 'DURATION') return { ...entry, value: '48:00' };
if (key === 'PATTERN START') return { ...entry, value: '2:00' };
if (key === 'REPORT START') return { ...entry, value: '3:00' };
if (key === 'STATISTIC') return { ...entry, value: 'MAXIMUM' };
return entry;
});
const updated = updateOptions(parsed, { rawEntries: qualityEntries, timeEntries });
const reparsed = parseInp(generateInp(updated));
assert.equal(reparsed.options.rawEntries.find((entry) => entry.key.toUpperCase() === 'QUALITY')?.value, 'AGE');
assert.equal(reparsed.options.timeEntries.find((entry) => entry.key.toUpperCase() === 'DURATION')?.value, '48:00');
assert.equal(reparsed.options.timeEntries.find((entry) => entry.key.toUpperCase() === 'PATTERN START')?.value, '2:00');
assert.equal(reparsed.options.timeEntries.find((entry) => entry.key.toUpperCase() === 'REPORT START')?.value, '3:00');
assert.equal(reparsed.options.timeEntries.find((entry) => entry.key.toUpperCase() === 'STATISTIC')?.value, 'MAXIMUM');
});
test('41. DISPLAY UNIT MODE: source labels and inverse pressure thresholds match EPANET units', () => {
assert.deepEqual(getDisplayUnits('LPS', 'korean'), {
pressure: 'm',
head: 'm',
flow: 'm³/day',
demand: 'm³/day',
velocity: 'm/s',
length: 'm',
diameter: 'mm',
});
// With no actual result yet, getDisplayUnits falls back to guessing psi
// for a US flow unit (see resolvePressureUnit's fallback branch).
assert.deepEqual(getDisplayUnits('GPM', 'original'), {
pressure: 'psi',
head: 'ft',
flow: 'GPM',
demand: 'GPM',
velocity: 'ft/s',
length: 'ft',
diameter: 'in',
});
// Once a real result exists, its own reported pressure unit -- which may
// differ from the flow-unit guess (EPANET 2.2+ EN_PRESSUNITS) -- wins.
assert.equal(getDisplayUnits('GPM', 'original', 'kPa').pressure, 'kPa');
assert.equal(getDisplayUnits('LPS', 'original', 'ft').pressure, 'ft');
const pressureMeters = pressureToMeters(50, 'psi', 1.2);
assert.ok(Math.abs(metersToPressure(pressureMeters, 'psi', 1.2) - 50) < 1e-10);
});
test('42. CAD BOX SELECTION: window requires containment while crossing accepts intersection', () => {
const nodes = [
{ id: 'inside', point: { x: 5, y: 5 } },
{ id: 'outside', point: { x: 15, y: 5 } },
];
const links = [
{ id: 'contained', points: [{ x: 2, y: 2 }, { x: 8, y: 8 }] },
{ id: 'crossing', points: [{ x: -5, y: 5 }, { x: 15, y: 5 }] },
{ id: 'outside', points: [{ x: 12, y: 12 }, { x: 18, y: 18 }] },
];
const windowSelection = selectNetworkFeaturesInBox(nodes, links, { x: 0, y: 0 }, { x: 10, y: 10 });
assert.equal(windowSelection.crossing, false);
assert.deepEqual([...windowSelection.nodes], ['inside']);
assert.deepEqual([...windowSelection.links], ['contained']);
const crossingSelection = selectNetworkFeaturesInBox(nodes, links, { x: 10, y: 10 }, { x: 0, y: 0 });
assert.equal(crossingSelection.crossing, true);
assert.deepEqual([...crossingSelection.nodes], ['inside']);
assert.deepEqual([...crossingSelection.links], ['contained', 'crossing']);
});
test('43. MAP SERVICE ERRORS: authorization, domain, quota, and network failures stay distinct', () => {
assert.match(formatMapServiceError(new MapServiceError('', 'authorization')), /API 키 인증/);
assert.match(formatMapServiceError(new MapServiceError('', 'domain')), /등록 도메인/);
assert.match(formatMapServiceError(new MapServiceError('', 'quota')), /호출 한도/);
assert.match(formatMapServiceError(new MapServiceError('', 'network')), /네트워크/);
});
test('44. EXTENDED KOREAN CRS: transforms and distance calculations across 5186, 5181, 5187, 5174, 102080, 102082, 3857, 5176', () => {
assert.ok(SUPPORTED_CRS_DEFINITIONS.length >= 19, 'Must define at least 19 supported CRS profiles');
const targetCodes: CRS[] = [
'EPSG:5186',
'EPSG:5181',
'EPSG:5187',
'EPSG:5174',
'EPSG:5176',
'EPSG:102080',
'EPSG:102082',
'EPSG:3857',
];
const seoulLon = 127.0;
const seoulLat = 37.5;
const dummyExtents = { minX: 0, minY: 0, maxX: 0, maxY: 0 };
for (const code of targetCodes) {
// 1. Forward model coords
const [modelX, modelY] = lngLatToModel(seoulLon, seoulLat, code, dummyExtents);
assert.ok(Number.isFinite(modelX) && Number.isFinite(modelY), `${code} forward transform must be finite`);
assert.notEqual(modelX, 0, `${code} modelX should not be zero for Seoul`);
// 2. Inverse to WGS84
const [recoveredLon, recoveredLat] = modelToLngLat(modelX, modelY, code, dummyExtents);
assert.ok(
Math.abs(recoveredLon - seoulLon) < 1e-4,
`${code} longitude round-trip diff too large: ${Math.abs(recoveredLon - seoulLon)}`
);
assert.ok(
Math.abs(recoveredLat - seoulLat) < 1e-4,
`${code} latitude round-trip diff too large: ${Math.abs(recoveredLat - seoulLat)}`
);
// 3. Metric pipe distance calculation
const distResult = calculateGeoAwareDistance(
{ x: modelX, y: modelY },
{ x: modelX + 300, y: modelY + 400 },
code,
'SI'
);
assert.ok(distResult.isPhysical, `${code} must be flagged as physically meaningful`);
if (code === 'EPSG:3857') {
// EPSG:3857 is projected via EPSG:5179 to correct the ~26% Web Mercator distortion in Seoul
assert.ok(Math.abs(distResult.distance - 395.94) < 1, `EPSG:3857 distance expected ~395.94m, got ${distResult.distance}`);
} else {
assert.equal(distResult.distance, 500, `${code} 3-4-5 delta must equal exactly 500 meters`);
}
}
});
test('45. SHAPEFILE EXPORT ROUNDTRIP: exportNetworkShapefileZip creates valid ESRI Shapefile Point and PolyLine archives', async () => {
const testInp = `[TITLE]
Test
[JUNCTIONS]
J1 10 5
J2 12 0
[PIPES]
P1 J1 J2 100 200 100 0 Open
[COORDINATES]
J1 10 10
J2 20 20
[END]`;
const sampleNet = parseInp(testInp);
const zipBytes = exportNetworkShapefileZip(sampleNet, null, 'EPSG:5179');
assert.ok(zipBytes.length > 500, 'Exported ZIP byte array must be non-empty');
// Roundtrip unzip
const unzipped = await unzipArchive(zipBytes.buffer);
assert.ok(unzipped['pipes.shp'], 'ZIP must contain pipes.shp');
assert.ok(unzipped['pipes.shx'], 'ZIP must contain pipes.shx');
assert.ok(unzipped['pipes.dbf'], 'ZIP must contain pipes.dbf');
assert.ok(unzipped['pipes.prj'], 'ZIP must contain pipes.prj');
assert.ok(unzipped['nodes.shp'], 'ZIP must contain nodes.shp');
assert.ok(unzipped['nodes.shx'], 'ZIP must contain nodes.shx');
assert.ok(unzipped['nodes.dbf'], 'ZIP must contain nodes.dbf');
assert.ok(unzipped['nodes.prj'], 'ZIP must contain nodes.prj');
// Parse back with internal shapefile parser
const pipeDbfRecords = parseDbfBinary(unzipped['pipes.dbf']);
const { features: pipeFeatures } = parseShpBinary(unzipped['pipes.shp'], pipeDbfRecords);
assert.equal(pipeFeatures.length, Object.keys(sampleNet.pipes).length, 'All pipes must be recovered');
assert.equal(pipeFeatures[0].geometry.type, 'LineString');
const nodeDbfRecords = parseDbfBinary(unzipped['nodes.dbf']);
const { features: nodeFeatures } = parseShpBinary(unzipped['nodes.shp'], nodeDbfRecords);
assert.equal(nodeFeatures.length, Object.keys(sampleNet.nodes).length, 'All nodes must be recovered');
assert.equal(nodeFeatures[0].geometry.type, 'Point');
});
test('46. NO AUTO RE-ANALYSIS ON EDIT: editing properties leaves analysis uncalled and sets stale flag', () => {
const baseInp = `[TITLE]
Test Model
[JUNCTIONS]
J1 10 5
[COORDINATES]
J1 10 10
[END]`;
const model = parseInp(baseInp);
const initialSnapshot = generateInp(model);
// Initially, before edit, stale is false
assert.equal(computeIsStale(generateInp(model), initialSnapshot), false);
// Edit node elevation without running analysis
let analysisRunCount = 0;
const mockRunAnalysis = () => { analysisRunCount++; };
const editedModel = {
...model,
nodes: {
...model.nodes,
J1: { ...model.nodes.J1, elevation: 25 },
},
};
// Property edited, but analysis was NOT called
assert.equal(analysisRunCount, 0, 'Analysis must NOT be auto-triggered on property edit');
// isStale flag must now be TRUE
const editedInp = generateInp(editedModel);
assert.equal(computeIsStale(editedInp, initialSnapshot), true, 'Model edit must mark result as stale');
});
test('47. PYPROJ REFERENCE COORDINATES VALIDATION (<0.01m difference)', () => {
// Test coordinates at Seoul (lon: 127.0, lat: 37.5) against official pyproj standards
const seoulLon = 127.0;
const seoulLat = 37.5;
const dummyExtents = { minX: 0, minY: 0, maxX: 0, maxY: 0 };
const pyprojReferences: Array<{ code: CRS; expectedX: number; expectedY: number }> = [
{ code: 'EPSG:5179', expectedX: 955804.816341, expectedY: 1944643.715789 },
{ code: 'EPSG:5186', expectedX: 200000.000000, expectedY: 544504.123486 },
{ code: 'EPSG:5185', expectedX: 376860.274923, expectedY: 546383.679359 },
{ code: 'EPSG:5187', expectedX: 23139.725077, expectedY: 546383.679359 },
{ code: 'EPSG:5188', expectedX: -153776.758307, expectedY: 552028.763947 },
{ code: 'EPSG:5180', expectedX: 376860.274923, expectedY: 446383.679359 },
{ code: 'EPSG:5181', expectedX: 200000.000000, expectedY: 444504.123486 },
{ code: 'EPSG:3857', expectedX: 14137575.330746, expectedY: 4509031.393077 },
];
for (const ref of pyprojReferences) {
const [modelX, modelY] = lngLatToModel(seoulLon, seoulLat, ref.code, dummyExtents);
const diff = Math.hypot(modelX - ref.expectedX, modelY - ref.expectedY);
assert.ok(
diff < 0.01,
`${ref.code} difference from pyproj reference exceeds 0.01m: got [${modelX}, ${modelY}], expected [${ref.expectedX}, ${ref.expectedY}], diff: ${diff.toFixed(6)}m`
);
}
});
test('48. UNDO / REDO 30-STEP RING BUFFER: batch edit -> undo -> restore original and oldest drop on >30 steps', () => {
const baseInp = `[TITLE]
Undo Test
[JUNCTIONS]
J1 10 5
J2 20 0
[PIPES]
P1 J1 J2 100 150 100 0 Open
P2 J1 J2 200 150 100 0 Open
[COORDINATES]
J1 10 10
J2 20 20
[END]`;
let currentModel = parseInp(baseInp);
const undoStack: typeof currentModel[] = [];
let redoStack: typeof currentModel[] = [];
const pushUndo = (modelToSave: typeof currentModel) => {
undoStack.push(JSON.parse(JSON.stringify(modelToSave)));
if (undoStack.length > 30) undoStack.shift();
redoStack = [];
};
const undo = () => {
if (undoStack.length === 0) return;
const prev = undoStack.pop()!;
redoStack.push(JSON.parse(JSON.stringify(currentModel)));
if (redoStack.length > 30) redoStack.shift();
currentModel = prev;
};
const redo = () => {
if (redoStack.length === 0) return;
const next = redoStack.pop()!;
undoStack.push(JSON.parse(JSON.stringify(currentModel)));
if (undoStack.length > 30) undoStack.shift();
currentModel = next;
};
// 1. Initial diameters are 150
assert.equal(currentModel.pipes.P1.diameter, 150);
assert.equal(currentModel.pipes.P2.diameter, 150);
// 2. Perform 1 batch edit: change both pipes to 250
pushUndo(currentModel);
currentModel = {
...currentModel,
pipes: {
...currentModel.pipes,
P1: { ...currentModel.pipes.P1, diameter: 250 },
P2: { ...currentModel.pipes.P2, diameter: 250 },
},
};
assert.equal(currentModel.pipes.P1.diameter, 250);
assert.equal(currentModel.pipes.P2.diameter, 250);
assert.equal(undoStack.length, 1);
// 3. Undo: restores original 150
undo();
assert.equal(currentModel.pipes.P1.diameter, 150, 'Undo must restore original diameter 150');
assert.equal(currentModel.pipes.P2.diameter, 150, 'Undo must restore original diameter 150');
assert.equal(redoStack.length, 1, 'Redo stack must have 1 entry');
// 4. Redo: re-applies 250
redo();
assert.equal(currentModel.pipes.P1.diameter, 250, 'Redo must re-apply diameter 250');
assert.equal(currentModel.pipes.P2.diameter, 250, 'Redo must re-apply diameter 250');
// 5. 35 edits test ring buffer cap at 30
for (let i = 1; i <= 35; i++) {
pushUndo(currentModel);
currentModel = {
...currentModel,
pipes: {
...currentModel.pipes,
P1: { ...currentModel.pipes.P1, diameter: 300 + i },
},
};
}
assert.equal(undoStack.length, 30, 'Undo stack must be capped at exactly 30 entries');
// The oldest entries (step 1..5: diameter 301..305) must have been discarded
assert.equal(undoStack[0].pipes.P1.diameter, 305, 'Oldest retained entry must be step 5 (diameter 305)');
assert.equal(undoStack[29].pipes.P1.diameter, 334, 'Youngest entry must be step 34 (diameter 334)');
});
test('49. BESSEL KOREAN 1985 DATUM SHIFT VALIDATION (<1.0m difference against pyproj.Transformer)', () => {
const dummyExtents = { minX: 0, minY: 0, maxX: 0, maxY: 0 };
const seoul = { lon: 126.978388, lat: 37.566610 };
const jeju = { lon: 126.5, lat: 33.4 };
// Hardcoded ground-truth reference values directly produced by pyproj.Transformer
const besselGroundTruth: Array<{
code: CRS;
seoulX: number;
seoulY: number;
jejuX: number;
jejuY: number;
}> = [
{ code: 'EPSG:5174', seoulX: 198021.0274, seoulY: 451592.0513, jejuX: 153408.5708, jejuY: -10582.5524 },
{ code: 'EPSG:5176', seoulX: 21332.2897, seoulY: 453514.6427, jejuX: -32663.8341, jejuY: -7898.6441 },
{ code: 'EPSG:5173', seoulX: 374709.1403, seoulY: 453430.3674, jejuX: 339458.4288, jejuY: -9690.2678 },
{ code: 'EPSG:5177', seoulX: -155412.7557, seoulY: 459204.6902, jejuX: -218848.7042, jejuY: -1628.0302 },
{ code: 'EPSG:5175', seoulX: 198021.0274, seoulY: 501592.0513, jejuX: 153408.5708, jejuY: 39417.4476 },
];
for (const ref of besselGroundTruth) {
// 1. Seoul test point
const [sX, sY] = lngLatToModel(seoul.lon, seoul.lat, ref.code, dummyExtents);
const sDiff = Math.hypot(sX - ref.seoulX, sY - ref.seoulY);
assert.ok(
sDiff < 1.0,
`${ref.code} Seoul diff ${sDiff.toFixed(4)}m exceeds 1.0m tolerance (got [${sX}, ${sY}], expected [${ref.seoulX}, ${ref.seoulY}])`
);
// 2. Jeju test point
const [jX, jY] = lngLatToModel(jeju.lon, jeju.lat, ref.code, dummyExtents);
const jDiff = Math.hypot(jX - ref.jejuX, jY - ref.jejuY);
assert.ok(
jDiff < 1.0,
`${ref.code} Jeju diff ${jDiff.toFixed(4)}m exceeds 1.0m tolerance (got [${jX}, ${jY}], expected [${ref.jejuX}, ${ref.jejuY}])`
);
}
});
test('50. R2 3-TIER NETWORK ROUND-TRIP: Anonymized real + Synthetic large (>2000 pipes) + Korean CP949', () => {
const networks = [
{ name: 'Anonymized Real', path: 'public/sample_pressure_network.inp' },
{ name: 'Synthetic Large 5179', path: 'public/synthetic_large_network_5179.inp' },
{ name: 'Korean CP949', path: 'public/korean_cp949_network.inp' },
];
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'r2_net_'));
try {
for (const net of networks) {
const buf = fs.readFileSync(net.path);
const decoded = decodeInpBytes(buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength));
const model = parseInp(decoded.text);
const nodeCount = Object.keys(model.nodes).length;
const linkCount = Object.keys(model.pipes).length + Object.keys(model.pumps).length + Object.keys(model.valves).length;
// Assert size criteria
if (net.name.includes('Large')) {
assert.ok(linkCount >= 2000, `Large network must have >= 2000 links, got ${linkCount}`);
}
if (net.name.includes('CP949')) {
assert.ok(Object.keys(model.nodes).some(id => /[가-힣]/.test(id)), 'CP949 network must contain Korean node IDs');
}
// Roundtrip regeneration & reparsing
const regenerated = generateInp(model);
const reparsed = parseInp(regenerated);
const reparsedNodeCount = Object.keys(reparsed.nodes).length;
const reparsedLinkCount = Object.keys(reparsed.pipes).length + Object.keys(reparsed.pumps).length + Object.keys(reparsed.valves).length;
assert.equal(reparsedNodeCount, nodeCount, `${net.name} node count must be conserved`);
assert.equal(reparsedLinkCount, linkCount, `${net.name} link count must be conserved`);
// C DLL execution verification
const inpPath = path.join(tmpDir, `${path.basename(net.path, '.inp')}_regen.inp`);
const rptPath = path.join(tmpDir, `${path.basename(net.path, '.inp')}_regen.rpt`);
const outPath = path.join(tmpDir, `${path.basename(net.path, '.inp')}_regen.out`);
fs.writeFileSync(inpPath, Buffer.from(new TextEncoder().encode(regenerated)));
const pyRunner = `import sys, os; sys.path.insert(0, os.path.abspath('.')); from backend.main import run_epanet; res = run_epanet(r'''${inpPath}''', r'''${rptPath}''', r'''${outPath}'''); assert len(res.get('nodes', {})) > 0; assert len(res.get('timeSteps', [])) >= 25; assert res['timeSteps'][-1] == 86400`;
const pythonExe = path.resolve('.venv/Scripts/python.exe');
execSync(`"${pythonExe}" -c "${pyRunner}"`);
}
} finally {
fs.rmSync(tmpDir, { recursive: true, force: true });
}
});
test('51. BATCH EDIT UNIT CONVERSION (P0-1): flow-unit system classification and display<->model round-trips', () => {
// The bug: BatchPropertyEditor used to guess US-vs-SI from the flow unit's
// first letter (G/C/M -> "US"), which misclassified CMH/CMD/CMS/MLD as US
// and never converted IMGD/AFD (which ARE US units). getUnitSystem must be
// the single source of truth, driven by the full EPANET flow-unit table.
const officialTable: Record<string, 'SI' | 'US'> = {
LPS: 'SI', LPM: 'SI', MLD: 'SI', CMH: 'SI', CMD: 'SI', CMS: 'SI',
CFS: 'US', GPM: 'US', MGD: 'US', IMGD: 'US', AFD: 'US',
};
for (const [unit, system] of Object.entries(officialTable)) {
assert.equal(getUnitSystem(unit), system, `${unit} must classify as ${system}`);
}
// Exact regression scenario: 200mm entered in the batch diameter field on an
// LPS (SI) model must be stored as 200 (mm), never 200/25.4 = 7.874in.
assert.equal(millimetersToDiameter(200, 'LPS'), 200);
// CMH/CMD/MLD share the SI system with LPS -- previously misclassified as US
// because their unit strings start with 'C' or 'M'.
for (const siUnit of ['CMH', 'CMD', 'MLD', 'CMS', 'LPM']) {
assert.equal(millimetersToDiameter(200, siUnit), 200, `${siUnit} diameter must stay 200mm`);
}
// IMGD/AFD are US units and previously received NO conversion at all.
for (const usUnit of ['IMGD', 'AFD', 'GPM', 'CFS', 'MGD']) {
const stored = millimetersToDiameter(200, usUnit);
assert.ok(Math.abs(stored - 200 / 25.4) < 1e-9, `${usUnit} diameter must convert mm->in, got ${stored}`);
assert.ok(Math.abs(diameterToMillimeters(stored, usUnit) - 200) < 1e-9, `${usUnit} diameter round-trip must recover 200mm`);
}
// Exact regression scenario: setting demand to 864 m3/day on an LPS model
// means 10 L/s -- it must not be stored as 864 in LPS.
const storedDemandLps = m3DayToFlow(864, 'LPS');
assert.ok(Math.abs(storedDemandLps - 10) < 1e-9, `864 m3/day on LPS must store as 10 L/s, got ${storedDemandLps}`);
assert.ok(Math.abs(flowToM3Day(storedDemandLps, 'LPS') - 864) < 1e-6);
// Demand round-trip across every EPANET flow unit (SI and US).
for (const unit of Object.keys(officialTable)) {
const stored = m3DayToFlow(864, unit);
const roundTripped = flowToM3Day(stored, unit);
assert.ok(Math.abs(roundTripped - 864) < 1e-6, `${unit} demand round-trip failed: got ${roundTripped}`);
}
// Elevation: a +5m offset entered on a US-units (GPM/ft) model must be
// converted to feet before being added to the stored (feet) elevation.
const elevOffsetFt = metersToLength(5, 'GPM');
assert.ok(Math.abs(elevOffsetFt - 5 * 3.280839895013123) < 1e-9);
assert.ok(Math.abs(lengthToMeters(elevOffsetFt, 'GPM') - 5) < 1e-9);
// On an SI model, meters pass through unchanged.
assert.equal(metersToLength(5, 'LPS'), 5);
});
test('52. FULL ATTRIBUTE TABLE ID EDIT (P0-2): rename survives INP export and invalid numbers are rejected, not zeroed', () => {
const sampleInp = `[TITLE]
Full Table ID Rename Test
[JUNCTIONS]
J1 10.0 5.0 ;
J2 12.0 8.0 ;
[RESERVOIRS]
R1 50.0 ;
[PIPES]
P1 R1 J1 100 200 100 0 Open ;
P2 J1 J2 150 150 100 0 Open ;
[CONTROLS]
LINK P1 OPEN IF NODE J1 BELOW 15
[OPTIONS]
UNITS LPS
[END]
`;
const model = parseInp(sampleInp);
// FullAttributeTableModal.commitEdit must route ID edits through the same
// updateNodeAttributes/updatePipeAttributes common mutator as the bottom
// attribute table -- not a raw spread that leaves the dictionary key and
// connected references pointing at the old ID.
let renamed = updateNodeAttributes(model, 'J1', { id: 'J_MAIN' });
assert.equal(renamed.nodes['J1'], undefined, 'old dictionary key must be gone');
assert.ok(renamed.nodes['J_MAIN'], 'new dictionary key must exist');
assert.equal(renamed.nodes['J_MAIN'].id, 'J_MAIN');
assert.equal(renamed.pipes['P1'].node2, 'J_MAIN', 'connected pipe endpoint must follow the rename');
assert.equal(renamed.pipes['P2'].node1, 'J_MAIN');
assert.equal(renamed.controls[0].nodeId, 'J_MAIN', 'control reference must follow the rename');
renamed = updatePipeAttributes(renamed, 'P1', { id: 'P_SOURCE' });
assert.equal(renamed.pipes['P1'], undefined);
assert.ok(renamed.pipes['P_SOURCE']);
assert.equal(renamed.controls[0].linkId, 'P_SOURCE', 'control link reference must follow the pipe rename');
// Round-trip through INP export/re-parse: connectivity must still hold.
const regenerated = generateInp(renamed);
const reparsed = parseInp(regenerated);
assert.ok(reparsed.nodes['J_MAIN']);
assert.equal(reparsed.nodes['J1'], undefined);
assert.ok(reparsed.pipes['P_SOURCE']);
assert.equal(reparsed.pipes['P_SOURCE'].node2, 'J_MAIN');
assert.equal(reparsed.pipes['P2'].node1, 'J_MAIN');
assert.equal(reparsed.controls.find((c) => c.linkId === 'P_SOURCE')?.nodeId, 'J_MAIN');
// Duplicate ID must be rejected with a clear error, exactly like the bottom table.
assert.throws(() => updateNodeAttributes(renamed, 'J2', { id: 'J_MAIN' }), /이미 존재하는/);
assert.throws(() => updatePipeAttributes(renamed, 'P2', { id: 'P_SOURCE' }), /이미 존재하는/);
// Invalid numeric input must be rejected by the shared validator, never
// silently coerced to 0 (the FullAttributeTableModal bug this closes).
const badElevation = validateSingleField('junction', 'elevation', 'not-a-number', 'J2', renamed);
assert.equal(badElevation.valid, false);
assert.notEqual(badElevation.parsedValue, 0);
const badInvertElev = validateSingleField('junction', 'invertElev', 'abc', 'J2', renamed);
assert.equal(badInvertElev.valid, false);
const badDiameter = validateSingleField('pipe', 'diameter', '-5', 'P2', renamed);
assert.equal(badDiameter.valid, false);
const badDemand = validateSingleField('junction', 'demand', '', 'J2', renamed);
assert.equal(badDemand.valid, false);
});
test('53. GIS IMPORT [TIMES] SECTION (P0-3): a GIS-converted model must emit its 24h time settings in generateInp', () => {
const geojson = {
type: 'FeatureCollection',
features: [
{
type: 'Feature',
properties: { FTR_IDN: 'PIPE_A', PIP_DIA: 200, PIP_MAT: 'DIP' },
geometry: {
type: 'LineString',
coordinates: [
[126.975, 37.565],
[126.978, 37.565],
],
},
},
],
};
const { model } = buildNetworkFromGeoJSON(geojson as any, {
pipeIdField: 'FTR_IDN',
diameterField: 'PIP_DIA',
materialField: 'PIP_MAT',
defaultDiameter: 200,
defaultRoughness: 120,
sourceHead: 60,
});
// Bug (pre-fix): buildNetworkFromGeoJSON populates options.timeEntries with a
// 24h duration, but its synthetic rawLines/sectionIndices never included a
// [TIMES] header, and generateInp only ever rewrote a [TIMES] section that
// already existed in sectionIndices -- so the time settings were silently
// dropped from every GIS-imported model's exported INP.
assert.equal(model.sectionIndices['TIMES'], undefined, 'fixture must reproduce the missing-header condition');
assert.ok(model.options.timeEntries.length > 0, 'GIS import must carry default 24h time settings');
const generated = generateInp(model);
assert.match(generated, /\[TIMES\]/, 'generateInp must emit a [TIMES] section even when the source never had one');
assert.match(generated, /Duration\s+24:00/);
assert.match(generated, /Hydraulic Timestep\s+1:00/);
const reparsed = parseInp(generated);
assert.equal(
reparsed.options.timeEntries.find((e) => e.key.toUpperCase() === 'DURATION')?.value,
'24:00'
);
});
test('54. INP SECTION ROUND-TRIP (P0-3): PATTERNS/CONTROLS/TIMES/OPTIONS added purely in the UI survive export even without a source header', () => {
// Minimal source INP with no [OPTIONS], [PATTERNS], [CONTROLS] or [TIMES]
// sections at all -- simulating a bare-bones or hand-trimmed INP onto which
// the user adds a pattern, a control, custom time settings, and an option
// purely through the UI (never present in the original file).
const bareInp = `[TITLE]
Bare INP
[JUNCTIONS]
J1 10 5 ;
[RESERVOIRS]
R1 60 ;
[PIPES]
P1 R1 J1 100 200 120 0 Open ;
[END]
`;
const base = parseInp(bareInp);
assert.equal(base.sectionIndices['PATTERNS'], undefined);
assert.equal(base.sectionIndices['CONTROLS'], undefined);
assert.equal(base.sectionIndices['TIMES'], undefined);
assert.equal(base.sectionIndices['OPTIONS'], undefined);
const withData: typeof base = {
...base,
patterns: {
PAT1: { id: 'PAT1', description: 'Daily demand pattern', multipliers: [0.8, 1.0, 1.2, 0.9] },
},
controls: [
{
linkId: 'P1',
status: 'CLOSED',
nodeId: 'J1',
condition: 'BELOW',
value: 5,
rawText: 'LINK P1 CLOSED IF NODE J1 BELOW 5',
},
],
options: {
...base.options,
demandModel: 'PDA',
timeEntries: [
{ key: 'Duration', value: '48:00' },
{ key: 'Hydraulic Timestep', value: '0:30' },
],
},
};
const generated = generateInp(withData);
assert.match(generated, /\[PATTERNS\]/);
assert.match(generated, /PAT1/);
assert.match(generated, /\[CONTROLS\]/);
assert.match(generated, /LINK P1 CLOSED IF NODE J1 BELOW 5/);
assert.match(generated, /\[TIMES\]/);
assert.match(generated, /Duration\s+48:00/);
assert.match(generated, /\[OPTIONS\]/);
assert.match(generated, /Demand Model\s+PDA/);
// Full round-trip: re-parse the generated text and confirm nothing was lost.
const reparsed = parseInp(generated);
assert.equal(reparsed.patterns['PAT1']?.multipliers.length, 4);
assert.equal(reparsed.patterns['PAT1']?.multipliers[2], 1.2);
assert.equal(reparsed.controls[0]?.linkId, 'P1');
assert.equal(reparsed.controls[0]?.status, 'CLOSED');
assert.equal(
reparsed.options.timeEntries.find((e) => e.key.toUpperCase() === 'DURATION')?.value,
'48:00'
);
assert.equal(reparsed.options.demandModel, 'PDA');
// Idempotency: regenerating from the re-parsed model (which now DOES have
// real section headers) must produce byte-identical output on a second pass.
const twice = generateInp(reparsed);
assert.equal(generateInp(parseInp(twice)), twice);
});
test('55. RAW-PRESERVED SECTION RENAME (P0-4): renameNode/renamePipe rewrite DEMANDS/QUALITY/SOURCES/EMITTERS/STATUS/RULES references', () => {
const sampleInp = `[TITLE]
P0-4 Rename Propagation Test
[JUNCTIONS]
J1 10.0 5.0 ;
J2 12.0 8.0 ;
[RESERVOIRS]
R1 50.0 ;
[PIPES]
P1 R1 J1 100 200 100 0 Open ;
P2 J1 J2 150 150 100 0 Open ;
[STATUS]
P2 CLOSED
[DEMANDS]
;Junction Demand Pattern Category
J1 5 1 Domestic
[QUALITY]
J1 0.5
[SOURCES]
J1 CONCEN 1.0
[EMITTERS]
J1 0.5
[RULES]
RULE RULE1
IF NODE J1 ABOVE 5
THEN LINK P2 CLOSED
[CONTROLS]
LINK P1 OPEN IF NODE J1 BELOW 15
[OPTIONS]
UNITS LPS
[END]
`;
const model = parseInp(sampleInp);
// Bug (pre-fix): renameNode/renamePipe only rewrote structured references
// (pipes/pumps/valves endpoints, Controls) and left the preserved raw text
// of DEMANDS/QUALITY/SOURCES/EMITTERS/STATUS/RULES pointing at the old ID.
const renamedNode = renameNode(model, 'J1', 'J_MAIN');
const demandsLine = renamedNode.rawLines[renamedNode.sectionIndices['DEMANDS'].start + 2];
assert.match(demandsLine, /^\s*J_MAIN\b/, 'DEMANDS row must follow the node rename');
const qualityLine = renamedNode.rawLines[renamedNode.sectionIndices['QUALITY'].start + 1];
assert.match(qualityLine, /^\s*J_MAIN\b/, 'QUALITY row must follow the node rename');
const sourcesLine = renamedNode.rawLines[renamedNode.sectionIndices['SOURCES'].start + 1];
assert.match(sourcesLine, /^\s*J_MAIN\b/, 'SOURCES row must follow the node rename');
const emittersLine = renamedNode.rawLines[renamedNode.sectionIndices['EMITTERS'].start + 1];
assert.match(emittersLine, /^\s*J_MAIN\b/, 'EMITTERS row must follow the node rename');
assert.ok(
renamedNode.rules.some((r) => r.includes('NODE J_MAIN') && !r.includes('NODE J1')),
'RULES text must follow the node rename'
);
const renamedBoth = renamePipe(renamedNode, 'P2', 'P_BRANCH');
const statusLine = renamedBoth.rawLines[renamedBoth.sectionIndices['STATUS'].start + 1];
assert.match(statusLine, /^\s*P_BRANCH\b/, 'STATUS row must follow the pipe rename');
assert.ok(
renamedBoth.rules.some((r) => r.includes('LINK P_BRANCH') && !r.includes('LINK P2 ')),
'RULES text must follow the pipe rename'
);
// Round-trip through export/re-parse: the renamed references must still resolve.
const reparsed = parseInp(generateInp(renamedBoth));
assert.equal(reparsed.sectionIndices['DEMANDS'] !== undefined, true);
const reDemands = reparsed.rawLines
.slice(reparsed.sectionIndices['DEMANDS'].start + 1, reparsed.sectionIndices['DEMANDS'].end + 1)
.join('\n');
assert.match(reDemands, /J_MAIN/);
assert.doesNotMatch(reDemands, /\bJ1\b/);
// [DEMANDS] rows REPLACE the junction's base demand in EPANET (verified
// against the 2.3.5 DLL), so the first category is the primary demand and a
// base-demand edit lands there instead of being rejected or double-counted.
const demandEdited = updateNodeAttributes(renamedBoth, 'J_MAIN', { demand: 99 });
assert.equal(demandEdited.extras!.demands['J_MAIN'][0].demand, 99);
assert.match(generateInp(demandEdited), /\[DEMANDS\][\s\S]*J_MAIN\s+99/);
// A node without any DEMANDS override edits normally.
const j2Edited = updateNodeAttributes(renamedBoth, 'J2', { demand: 42 });
assert.equal(j2Edited.nodes['J2'].demand, 42);
// Guard: editing the status of a link with a preserved [STATUS] override
// must be rejected -- STATUS wins at solve time regardless of what the
// PIPES/VALVES status column says, so silently "changing" it here would do
// nothing at solve time while the UI shows the new value.
assert.equal(renamedBoth.pipes['P_BRANCH'].status, 'Open', 'PIPES line status (pre-edit baseline)');
assert.equal(renamedBoth.extras!.statusOverrides['P_BRANCH'], 'CLOSED', 'STATUS override follows the rename');
// [STATUS] wins at solve time, so a status edit updates the override too.
const statusEdited = updatePipeAttributes(
updatePipeAttributes(renamedBoth, 'P_BRANCH', { status: 'Closed' }),
'P_BRANCH',
{ status: 'Open' }
);
assert.equal(statusEdited.extras!.statusOverrides['P_BRANCH'], 'OPEN');
assert.match(generateInp(statusEdited), /\[STATUS\][\s\S]*P_BRANCH\s+OPEN/);
// A pipe without any STATUS override edits normally.
const p1Edited = updatePipeAttributes(renamedBoth, 'P1', { status: 'Closed' });
assert.equal(p1Edited.pipes['P1'].status, 'Closed');
});
test('56. PRESSURE UNIT HANDLING (P0-5): kPa/bar/ft conversions and correct low-pressure judgement from the engine-reported unit', () => {
// resolvePressureUnit must use the engine's own reported unit verbatim...
assert.equal(resolvePressureUnit('kPa', 'LPS'), 'kPa');
assert.equal(resolvePressureUnit('bar', 'GPM'), 'bar');
assert.equal(resolvePressureUnit('ft', 'LPS'), 'ft');
// ...and only fall back to a flow-unit-based guess when no result exists yet.
assert.equal(resolvePressureUnit(undefined, 'GPM'), 'psi');
assert.equal(resolvePressureUnit(undefined, 'LPS'), 'm');
assert.equal(resolvePressureUnit('Unknown', 'CMH'), 'm');
// Round-trip every EPANET pressure unit through pressureToMeters/metersToPressure.
for (const unit of ['psi', 'kPa', 'm', 'bar', 'ft']) {
for (const sg of [1.0, 1.2]) {
const meters = pressureToMeters(50, unit, sg);
const back = metersToPressure(meters, unit, sg);
assert.ok(Math.abs(back - 50) < 1e-9, `${unit} @ SG=${sg} round-trip failed: got ${back}`);
}
}
// kPa/bar are true pressure quantities and must scale with specific gravity,
// exactly like psi already does -- higher SG means less head for the same
// reported pressure.
assert.ok(Math.abs(pressureToMeters(98.0665, 'kPa', 1.0) - 10) < 1e-9);
assert.ok(Math.abs(pressureToMeters(98.0665, 'kPa', 2.0) - 5) < 1e-9);
assert.ok(Math.abs(pressureToMeters(1, 'bar', 1.0) - pressureToMeters(100, 'kPa', 1.0)) < 1e-9);
// ft, like m, is already a head-of-fluid length: pure unit conversion, no SG.
assert.ok(Math.abs(pressureToMeters(1, 'ft', 1.0) - pressureToMeters(1, 'ft', 3.0)) < 1e-12);
// Bug scenario: a model whose pressure is reported in kPa (independent of
// its LPS flow unit, per EPANET's EN_PRESSUNITS) reports 98.0665 kPa at a
// junction -- a real 10m head, which is a low-pressure violation against a
// 15m threshold. The pre-fix code guessed the pressure unit from the flow
// unit's US/SI system (LPS -> not "US" -> treated as already-meters), so it
// would read this as "98.0665 m" and wrongly conclude the node is fine.
const threshold = 15;
const rawPressureKpa = 98.0665;
const correctMeters = pressureToMeters(rawPressureKpa, resolvePressureUnit('kPa', 'LPS'), 1.0);
assert.ok(Math.abs(correctMeters - 10) < 1e-9);
assert.ok(correctMeters < threshold, 'must be correctly flagged as a low-pressure violation');
});
test('57. UNIT HEADLOSS vs TOTAL HEADLOSS (P0-6): comparing pipes of different lengths must use the length-normalized rate', () => {
// EN_HEADLOSS is the TOTAL head difference across the whole pipe -- it
// scales with length, so a longer pipe can show a bigger number than a
// shorter, much-worse pipe purely because it's longer.
const shortSeverePipe = { length: 50, totalHeadloss: 4 }; // 80 ‰ -- genuinely bad
const longMildPipe = { length: 2000, totalHeadloss: 6 }; // 3 ‰ -- perfectly fine
// Comparing raw totals would wrongly rank the long, mild pipe as "worse".
assert.ok(
longMildPipe.totalHeadloss > shortSeverePipe.totalHeadloss,
'raw totals alone would misrank these two pipes'
);
const shortUnitHl = computeUnitHeadloss(shortSeverePipe.totalHeadloss, shortSeverePipe.length);
const longUnitHl = computeUnitHeadloss(longMildPipe.totalHeadloss, longMildPipe.length);
assert.ok(Math.abs(shortUnitHl - 80) < 1e-9);
assert.ok(Math.abs(longUnitHl - 3) < 1e-9);
// The length-normalized rate correctly ranks the short pipe as far worse.
assert.ok(shortUnitHl > longUnitHl, 'unit headloss must correctly identify the short pipe as the severe one');
// Zero-length (or missing) pipes must not divide by zero.
assert.equal(computeUnitHeadloss(5, 0), 0);
});
test('58. SCENARIO INP/RESULT PAIRING (P0-7): base scenario never inherits a result computed from a different model version', () => {
const baseInp = `[TITLE]
Scenario Base
[JUNCTIONS]
J1 10 10 ;
[RESERVOIRS]
R1 50 ;
[PIPES]
P1 R1 J1 100 200 100 0 Open ;
[COORDINATES]
J1 10 10
R1 0 0
[OPTIONS]
UNITS LPS
[END]
`;
const originalModel = parseInp(baseInp);
const normalizedOriginal = generateInp(originalModel);
const fakeResult = (tag: string) =>
({
engine: { runtime: 'wasm', version: '2.3.5' },
timeSeconds: 0,
units: { flow: 'LPS', pressure: 'm' },
nodes: {},
links: {},
__tag: tag,
}) as unknown as SimulationResult;
// --- Bug scenario: the user edits the model and re-analyzes BEFORE ever
// creating a scenario, so the live result reflects the EDITED model, not
// the original file, by the time handleCreateScenario builds 'base'.
const editedModel = {
...originalModel,
nodes: { ...originalModel.nodes, J1: { ...originalModel.nodes['J1'], elevation: 99 } },
};
const editedInp = generateInp(editedModel);
assert.notEqual(editedInp, normalizedOriginal, 'edit must actually change the regenerated INP');
const editedResult = fakeResult('edited');
const resultInpSnapshotAfterEdit = editedInp; // runAnalysis(editedInp) just completed
const staleAfterEdit = computeIsStale(editedInp, resultInpSnapshotAfterEdit); // false: matches what was just analyzed
// Pre-fix behavior was `initialResult || wasmResult`, which would have
// attached editedResult to 'base' here. The fix must refuse to.
const baseResult = deriveBaseScenarioResult(editedResult, staleAfterEdit, resultInpSnapshotAfterEdit, normalizedOriginal);
assert.equal(baseResult, null, "base must not inherit a result computed from the edited model");
// Build the scenario list the way handleCreateScenario now does.
let scenarios: Scenario[] = saveActiveScenarioState([], 'base', editedInp, editedResult, staleAfterEdit);
scenarios.push({ id: 'base', name: 'base', inpStr: normalizedOriginal, result: baseResult, createdAt: 'now' });
scenarios.push({
id: 'scen_1',
name: 'alt1',
inpStr: editedInp,
result: staleAfterEdit ? null : editedResult,
createdAt: 'now',
});
assert.equal(scenarios.find((s) => s.id === 'base')?.result, null);
assert.equal(scenarios.find((s) => s.id === 'scen_1')?.result, editedResult, 'scen_1 correctly keeps its own matching result');
assert.equal(scenarios.find((s) => s.id === 'scen_1')?.inpStr, editedInp);
// --- Switch back to base (handleSwitchScenario): base has no result yet,
// forcing a fresh analysis of the TRUE original text.
const baseEntry = scenarios.find((s) => s.id === 'base')!;
assert.equal(baseEntry.result, null, 'switching to base must not surface a stale/foreign result');
const baseAnalysisResult = fakeResult('base-analyzed');
const baseResultInpSnapshot = baseEntry.inpStr;
const baseStale = computeIsStale(baseEntry.inpStr, baseResultInpSnapshot);
scenarios = saveActiveScenarioState(scenarios, 'base', baseEntry.inpStr, baseAnalysisResult, baseStale);
assert.equal(scenarios.find((s) => s.id === 'base')?.result, baseAnalysisResult);
assert.equal(scenarios.find((s) => s.id === 'base')?.inpStr, normalizedOriginal, "base's INP must remain the true original");
// --- Create a second alternative from base's freshly-analyzed state and
// confirm every scenario's INP/result pair is still mutually consistent
// (each carries either null or a result tagged for exactly its own INP).
scenarios = saveActiveScenarioState(scenarios, 'base', baseEntry.inpStr, baseAnalysisResult, baseStale);
scenarios.push({
id: 'scen_2',
name: 'alt2',
inpStr: baseEntry.inpStr,
result: baseStale ? null : baseAnalysisResult,
createdAt: 'now',
});
const tagOf = (r: SimulationResult | null) => (r as unknown as { __tag: string } | null)?.__tag;
assert.equal(scenarios.find((s) => s.id === 'base')?.result, baseAnalysisResult, "base result must survive scen_2's creation untouched");
assert.equal(tagOf(scenarios.find((s) => s.id === 'scen_2')?.result ?? null), 'base-analyzed');
assert.equal(tagOf(scenarios.find((s) => s.id === 'scen_1')?.result ?? null), 'edited');
// No scenario ever ends up with a result tag that doesn't belong to its own inpStr.
for (const s of scenarios) {
if (s.result) {
assert.equal(computeIsStale(s.inpStr, s.inpStr), false, `scenario ${s.id} must be internally consistent`);
}
}
});
test('59. AUTOSAVE FULL PROJECT STATE (P0-8): scenarios/results/GIS layers survive the v1->v2 snapshot migration', () => {
const model = parseInp(`[TITLE]
Autosave Test
[JUNCTIONS]
J1 10 5 ;
[RESERVOIRS]
R1 50 ;
[PIPES]
P1 R1 J1 100 200 100 0 Open ;
[END]
`);
const fakeResult = { engine: { runtime: 'wasm', version: '2.3.5' }, timeSeconds: 0, units: { flow: 'LPS', pressure: 'm' }, nodes: {}, links: {} } as unknown as SimulationResult;
// A v2 snapshot (this fix) must round-trip every field untouched.
const v2Stored = {
id: 'tab_abc',
version: 2 as const,
savedAt: '2026-01-01T00:00:00.000Z',
fileName: 'net.inp',
networkModel: model,
crs: 'EPSG:4326' as unknown as CRS,
basemap: 'none' as const,
displayUnitMode: 'korean' as const,
styleSettings: {} as unknown as Parameters<typeof normalizeStoredSnapshot>[0]['styleSettings'],
isModified: true,
rawInp: 'ORIGINAL RAW TEXT',
scenarios: [
{ id: 'base', name: '원안', inpStr: 'ORIGINAL RAW TEXT', result: fakeResult, createdAt: 'now' },
{ id: 'scen_1', name: '대안 1', inpStr: 'EDITED TEXT', result: null, createdAt: 'now' },
],
activeScenarioId: 'scen_1',
wasmResult: fakeResult,
serverResult: fakeResult,
resultInpSnapshot: 'EDITED TEXT',
userLayers: [{ id: 'layer1', name: 'ref layer' } as unknown as (typeof v2Stored)['userLayers'][number]],
};
const normalized = normalizeStoredSnapshot(v2Stored as never);
assert.ok(normalized);
assert.equal(normalized!.scenarios.length, 2);
assert.equal(normalized!.scenarios[0].result, fakeResult);
assert.equal(normalized!.activeScenarioId, 'scen_1');
assert.equal(normalized!.wasmResult, fakeResult);
assert.equal(normalized!.userLayers.length, 1);
assert.equal(normalized!.rawInp, 'ORIGINAL RAW TEXT');
// An old (pre-P0-8) v1 snapshot must still load -- degraded (no scenarios/
// results/layers) rather than discarded outright or crashing the restore.
const v1Stored = {
id: 'latest',
version: 1 as const,
savedAt: '2025-01-01T00:00:00.000Z',
fileName: 'old.inp',
networkModel: model,
crs: 'EPSG:4326' as unknown as CRS,
basemap: 'none' as const,
displayUnitMode: 'korean' as const,
styleSettings: {} as unknown as Parameters<typeof normalizeStoredSnapshot>[0]['styleSettings'],
isModified: false,
};
const migrated = normalizeStoredSnapshot(v1Stored as never);
assert.ok(migrated);
assert.equal(migrated!.scenarios.length, 0);
assert.equal(migrated!.wasmResult, null);
assert.equal(migrated!.userLayers.length, 0);
assert.equal(migrated!.activeScenarioId, 'base');
assert.equal(migrated!.networkModel, model);
// A record with no networkModel at all (corrupt/empty) must be rejected, not crash.
assert.equal(normalizeStoredSnapshot({ id: 'x', version: 2 } as never), null);
});
test('60. EXCEL EXPORT SELECTED TIME (P0-9): the workbook must use the on-screen selected time step, not always the first', () => {
// Bug (pre-fix): exportHydraulicCalculationXlsx read only the result's flat
// (first-step) fields (res.pressure / res.flow / ...) and never consulted
// res.timeSeries at all, so selecting a later time on screen before
// exporting had no effect on the workbook.
const pressureSeries = [50, 42, 30, 18];
const flatFirstStepValue = pressureSeries[0];
// Selecting time step 2 (index 2) must yield THAT step's value, not step 0's.
assert.equal(seriesValue(pressureSeries, 2, flatFirstStepValue), 30);
assert.equal(seriesValue(pressureSeries, 0, flatFirstStepValue), 50);
assert.equal(seriesValue(pressureSeries, 3, flatFirstStepValue), 18);
// No time series (steady-state result) -- falls back to the flat value.
assert.equal(seriesValue(undefined, 2, flatFirstStepValue), flatFirstStepValue);
// No time step selected at all -- also falls back (never index into the series blindly).
assert.equal(seriesValue(pressureSeries, undefined, flatFirstStepValue), flatFirstStepValue);
// Out-of-range index -- falls back rather than returning undefined.
assert.equal(seriesValue(pressureSeries, 99, flatFirstStepValue), flatFirstStepValue);
// The exported workbook must also record WHICH instant it represents.
const timeSteps = [0, 3600, 7200, 10800];
assert.equal(formatTimeLabel(timeSteps, 2), '02:00 (7200초)');
assert.equal(formatTimeLabel(timeSteps, 0), '00:00 (0초)');
assert.equal(formatTimeLabel(undefined, 2), '정상상태(Steady-State)');
assert.equal(formatTimeLabel(timeSteps, undefined), '정상상태(Steady-State)');
});
test('61. RESERVOIR/TANK/PUMP EDITS PERSIST (P1-1): full attribute table columns that look editable actually save', () => {
const sampleInp = `[TITLE]
Reservoir Tank Pump Edit Test
[JUNCTIONS]
J1 10 5 ;
J2 12 8 ;
[RESERVOIRS]
R1 50 ;
[TANKS]
T1 20 5 0 10 15 0 ;
[PUMPS]
PU1 R1 J1 HEAD C1 ;
[PIPES]
P1 T1 J1 100 200 100 0 Open ;
P2 J1 J2 150 150 100 0 Open ;
[CURVES]
C1 100 50
[CONTROLS]
LINK PU1 OPEN IF NODE J1 BELOW 15
[OPTIONS]
UNITS LPS
[END]
`;
const model = parseInp(sampleInp);
// Reservoir 'head' must actually update the model (and stay in sync with elevation).
const withReservoirEdit = updateNodeAttributes(model, 'R1', { head: 55, elevation: 55 });
assert.equal(withReservoirEdit.nodes['R1'].head, 55);
assert.equal(withReservoirEdit.nodes['R1'].elevation, 55);
// Reservoir/Tank id rename must go through renameNode (updates PIPES/PUMPS endpoints).
const renamedReservoir = updateNodeAttributes(withReservoirEdit, 'R1', { id: 'SOURCE' });
assert.equal(renamedReservoir.nodes['R1'], undefined);
assert.ok(renamedReservoir.nodes['SOURCE']);
assert.equal(renamedReservoir.pumps['PU1'].node1, 'SOURCE', 'pump endpoint must follow the reservoir rename');
// Tank numeric fields (elevation/initLevel/minLevel/maxLevel/diameter) must persist.
const withTankEdit = updateNodeAttributes(renamedReservoir, 'T1', {
elevation: 25,
initLevel: 6,
minLevel: 1,
maxLevel: 12,
diameter: 18,
});
assert.equal(withTankEdit.nodes['T1'].elevation, 25);
assert.equal(withTankEdit.nodes['T1'].initLevel, 6);
assert.equal(withTankEdit.nodes['T1'].diameter, 18);
// Tank rename must update the connected pipe's endpoint.
const renamedTank = updateNodeAttributes(withTankEdit, 'T1', { id: 'TANK_MAIN' });
assert.equal(renamedTank.pipes['P1'].node1, 'TANK_MAIN');
// Node tag (junction, reservoir, or tank) must round-trip through INP export/re-parse --
// [TAGS] previously only ever stored LINK entries, so a NODE tag was silently dropped.
const withTags = {
...renamedTank,
nodes: {
...renamedTank.nodes,
J2: { ...renamedTank.nodes['J2'], tag: '중요절점' },
SOURCE: { ...renamedTank.nodes['SOURCE'], tag: '취수원' },
},
};
const regenerated = generateInp(withTags);
assert.match(regenerated, /NODE\s+J2\s+중요절점/);
assert.match(regenerated, /NODE\s+SOURCE\s+취수원/);
const reparsed = parseInp(regenerated);
assert.equal(reparsed.nodes['J2'].tag, '중요절점');
assert.equal(reparsed.nodes['SOURCE'].tag, '취수원');
// Pump id/node1/node2/parameters edits must actually save (previously
// commitEdit had no branch for 'pumps' at all -- every pump edit silently
// did nothing).
const withPumpEdit = updatePumpAttributes(renamedTank, 'PU1', { parameters: 'POWER 15' });
assert.equal(withPumpEdit.pumps['PU1'].parameters, 'POWER 15');
const renamedPump = updatePumpAttributes(withPumpEdit, 'PU1', { id: 'PUMP_A' });
assert.equal(renamedPump.pumps['PU1'], undefined);
assert.ok(renamedPump.pumps['PUMP_A']);
assert.equal(
renamedPump.controls.find((c) => c.linkId === 'PUMP_A')?.linkId,
'PUMP_A',
'control reference must follow the pump rename'
);
// Duplicate pump id (colliding with an existing pipe/link id), self-loop,
// and nonexistent node must all be rejected.
assert.throws(() => updatePumpAttributes(renamedPump, 'PUMP_A', { id: 'P1' }), /이미 존재하는/);
assert.throws(() => updatePumpAttributes(renamedPump, 'PUMP_A', { node2: 'SOURCE' }), /달라야 합니다|존재하지 않는/);
assert.throws(() => updatePumpAttributes(renamedPump, 'PUMP_A', { node1: 'NOPE' }), /존재하지 않는/);
// Full round-trip: rename + parameter edit must survive export and re-parse.
const finalRegen = generateInp(renamedPump);
const finalReparsed = parseInp(finalRegen);
assert.ok(finalReparsed.pumps['PUMP_A']);
assert.match(finalReparsed.pumps['PUMP_A'].parameters, /POWER\s+15/);
});
test('62. INDEPENDENT ENGINE RESULTS (P1-2): a server (Native DLL) failure must not withhold a successful WASM result', () => {
const fakeResult = (tag: string) =>
({ engine: { runtime: 'wasm', version: '2.3.5' }, timeSeconds: 0, units: { flow: 'LPS', pressure: 'm' }, nodes: {}, links: {}, __tag: tag }) as unknown as SimulationResult;
// Bug scenario: server rejects, WASM succeeds. The old Promise.all-based
// code would have thrown on the server rejection and never surfaced the
// WASM result at all.
const wasmOk = fakeResult('wasm-ok');
const serverRejected: PromiseSettledResult<SimulationResult> = { status: 'rejected', reason: new Error('DLL 연결 실패') };
const wasmFulfilled: PromiseSettledResult<SimulationResult> = { status: 'fulfilled', value: wasmOk };
const outcome1 = resolveDualEngineOutcome(serverRejected, wasmFulfilled);
assert.equal(outcome1.server, null);
assert.equal(outcome1.wasm, wasmOk, 'WASM result must survive a server-side failure');
assert.equal(outcome1.failureMessages.length, 1);
assert.match(outcome1.failureMessages[0], /서버\(Native\)/);
// Symmetric case: WASM rejects, server succeeds.
const serverOk = fakeResult('server-ok');
const outcome2 = resolveDualEngineOutcome(
{ status: 'fulfilled', value: serverOk },
{ status: 'rejected', reason: new Error('워커 초기화 실패') }
);
assert.equal(outcome2.wasm, null);
assert.equal(outcome2.server, serverOk, 'server result must survive a WASM-side failure');
assert.match(outcome2.failureMessages[0], /WASM/);
// Both succeed: no failure messages, both results present (cross-validation possible).
const outcome3 = resolveDualEngineOutcome(
{ status: 'fulfilled', value: serverOk },
{ status: 'fulfilled', value: wasmOk }
);
assert.equal(outcome3.failureMessages.length, 0);
assert.equal(outcome3.server, serverOk);
assert.equal(outcome3.wasm, wasmOk);
// Both fail: both null, two failure messages, neither engine's absence masks the other's.
const outcome4 = resolveDualEngineOutcome(
{ status: 'rejected', reason: new Error('a') },
{ status: 'rejected', reason: new Error('b') }
);
assert.equal(outcome4.server, null);
assert.equal(outcome4.wasm, null);
assert.equal(outcome4.failureMessages.length, 2);
});
test('63. UNIFIED WARNING THRESHOLDS (P1-3): reports/tables converge on the same project-wide criteria as the map', () => {
// SI model: minPressureThreshold (15m) and maxVelocityThreshold (3 m/s,
// the map default) must pass through to 'm' and 'm/s' unchanged.
const si = resolveNativeThresholds(15, 3, 'm', 'LPS', 1.0);
assert.equal(si.minPressureNative, 15);
assert.equal(si.maxVelocityNative, 3);
// US model reporting psi: previously excelExport.ts hardcoded its OWN
// "2.5 m/s" (converted crudely to a flat US velocity number) and "20 psi"
// standard, independent of the map's user-adjustable setting. Now the
// same 15m/3m/s project setting must convert into the model's native units.
const us = resolveNativeThresholds(15, 3, 'psi', 'GPM', 1.0);
// 15m of water ~= 21.32 psi (via the same PSI_TO_M_WATER constant used
// throughout the app's pressure conversions).
assert.ok(Math.abs(us.minPressureNative - 21.3238) < 0.001);
// 3 m/s ~= 9.84 ft/s.
assert.ok(Math.abs(us.maxVelocityNative - 9.8425) < 0.001);
// A project override (e.g. a stricter 20m minimum) must also propagate,
// not just the defaults -- there is exactly one source of truth.
const overridden = resolveNativeThresholds(20, 2, 'm', 'LPS', 1.0);
assert.equal(overridden.minPressureNative, 20);
assert.equal(overridden.maxVelocityNative, 2);
// A kPa-reporting project must also convert correctly (specific gravity applies).
const kpa = resolveNativeThresholds(10, 3, 'kPa', 'LPS', 1.2);
assert.ok(Math.abs(kpa.minPressureNative - 10 * 9.80665 * 1.2) < 1e-6);
});
test('64. ENGINE ISSUES LINKED TO OBJECTS (P1-4): report warnings/errors are matched to the node/link they concern', () => {
const nodeIds = ['J1', 'J2', 'R1'];
const linkIds = ['P1', 'P2', 'PU1'];
const reportText = `EPANET Analysis
Hydraulic Status
WARNING: Node J2 disconnected at 2:00 hrs
Error 233: Pump PU1 not connected to any node
System unbalanced at 3:00 hrs
Everything else is fine here
`;
const issues = extractEngineIssues(reportText, nodeIds, linkIds);
const nodeIssue = issues.find((i) => i.message.includes('J2'));
assert.ok(nodeIssue, 'must find the WARNING line naming J2');
assert.deepEqual(nodeIssue!.target, { type: 'node', id: 'J2' });
assert.equal(nodeIssue!.severity, 'warning');
const linkIssue = issues.find((i) => i.message.includes('PU1'));
assert.ok(linkIssue, 'must find the Error line naming PU1');
assert.deepEqual(linkIssue!.target, { type: 'link', id: 'PU1' });
assert.equal(linkIssue!.severity, 'error');
// A flagged line naming no known id gets no clickable target, not a crash
// or a wrong guess.
const untargeted = issues.find((i) => i.message.includes('unbalanced'));
assert.ok(untargeted);
assert.equal(untargeted!.target, null);
// Ordinary report lines (no WARNING/Error/disconnected/etc keyword) are not
// reported as issues at all.
assert.ok(!issues.some((i) => i.message.includes('Everything else')));
assert.ok(!issues.some((i) => i.message.includes('Hydraulic Status')));
// No report text, or a model with no ids at all -- empty, no crash.
assert.deepEqual(extractEngineIssues(null, nodeIds, linkIds), []);
assert.deepEqual(extractEngineIssues(reportText, [], []), []);
});
test('65. ISOLATED CLUSTER DETECTION (P1-5): a group of mutually-connected nodes unreachable from any source must be flagged', () => {
// J3-J4-J5 form their own little loop (each has degree >= 1, so the old
// degree-0-only check never caught this), but that loop is never actually
// tied into the main R1-J1-J2 network at all.
const sampleInp = `[TITLE]
Isolated Cluster Test
[JUNCTIONS]
J1 10 5 ;
J2 10 5 ;
J3 10 5 ;
J4 10 5 ;
J5 10 5 ;
[RESERVOIRS]
R1 50 ;
[PIPES]
P1 R1 J1 100 200 100 0 Open ;
P2 J1 J2 100 200 100 0 Open ;
P3 J3 J4 100 200 100 0 Open ;
P4 J4 J5 100 200 100 0 Open ;
P5 J5 J3 100 200 100 0 Open ;
[COORDINATES]
J1 0 0
J2 1 0
J3 10 10
J4 11 10
J5 10 11
R1 -1 0
[OPTIONS]
UNITS LPS
[END]
`;
const model = parseInp(sampleInp);
const issues = validateTopology(model);
// None of J3/J4/J5 has degree 0, so the pre-existing isolated-node check
// must NOT fire for them.
const degreeZeroIssues = issues.filter((i) => i.message.includes('연결된 관로/밸브가 없습니다'));
assert.equal(degreeZeroIssues.length, 0, 'no node in the isolated loop has degree 0');
// A single clustered-isolation issue must be reported naming all three.
const clusterIssue = issues.find((i) => i.message.includes('고립 관망'));
assert.ok(clusterIssue, 'must detect the J3-J4-J5 loop as disconnected from any source');
assert.match(clusterIssue!.message, /3개/);
for (const id of ['J3', 'J4', 'J5']) {
assert.match(clusterIssue!.message, new RegExp(id));
}
assert.ok(clusterIssue!.target && ['J3', 'J4', 'J5'].includes(clusterIssue!.target.id));
// A model where every node IS reachable from the source must report none.
const connectedInp = sampleInp.replace(' P5 J5 J3 100 200 100 0 Open ;\n', ' P5 J2 J3 100 200 100 0 Open ;\n');
const connectedModel = parseInp(connectedInp);
const connectedIssues = validateTopology(connectedModel);
assert.ok(!connectedIssues.some((i) => i.message.includes('고립 관망')));
});
test('66. GIS IMPORT DISCLOSES ESTIMATED VALUES (P1-6): the conversion summary flags placeholders and fuzzy endpoint matches', () => {
// Two segments: the second's start point (126.9780001, 37.565) is NOT
// exactly equal to the first segment's end point (126.978, 37.565), but
// falls within the geographic snap threshold (~5m) -- a real shared
// endpoint from slightly noisy GIS digitizing, or two genuinely distinct
// points close enough to be merged by mistake. Either way it needs review.
const geojson = {
type: 'FeatureCollection',
features: [
{
type: 'Feature',
properties: { FTR_IDN: 'PIPE_A', PIP_DIA: 300 },
geometry: { type: 'LineString', coordinates: [[126.975, 37.565], [126.978, 37.565]] },
},
{
type: 'Feature',
properties: { FTR_IDN: 'PIPE_B' }, // no diameter field at all -> must fall back to default
geometry: { type: 'LineString', coordinates: [[126.9780001, 37.565], [126.981, 37.565]] },
},
],
};
const { model, summary } = buildNetworkFromGeoJSON(geojson as any, {
pipeIdField: 'FTR_IDN',
diameterField: 'PIP_DIA',
defaultDiameter: 200,
defaultRoughness: 120,
sourceHead: 60,
});
// PIPE_B's near-but-not-exact start point must have snapped onto PIPE_A's
// end node rather than creating a redundant new one.
assert.equal(Object.keys(model.nodes).length, 3, 'the fuzzy-matched endpoint must merge into 3 total nodes, not 4');
assert.equal(summary.autoSnappedEndpointCount, 1, 'exactly one fuzzy (non-exact) endpoint match occurred');
// PIPE_A had a real diameter field; PIPE_B did not (falls back to default).
assert.equal(summary.defaultDiameterPipeCount, 1);
assert.equal(summary.totalPipeCount, 2);
// Neither pipe has a roughness field or material field -- both estimated.
assert.equal(summary.defaultRoughnessPipeCount, 2);
// Every non-source node's elevation/demand is an undisclosed placeholder;
// one node became the source reservoir and is excluded from that count.
assert.equal(summary.totalNodeCount, 3);
assert.equal(summary.placeholderElevationCount, 2);
assert.equal(summary.placeholderDemandCount, 2);
// A model with no exact-duplicate endpoints at all must report zero
// auto-snapped merges (only genuinely fuzzy matches count).
const disjointGeojson = {
type: 'FeatureCollection',
features: [
{ type: 'Feature', properties: { FTR_IDN: 'X' }, geometry: { type: 'LineString', coordinates: [[10, 10], [20, 20]] } },
],
};
const disjoint = buildNetworkFromGeoJSON(disjointGeojson as any, {
defaultDiameter: 200,
defaultRoughness: 120,
sourceHead: 60,
});
assert.equal(disjoint.summary.autoSnappedEndpointCount, 0);
});
test('67. UNIFIED EDIT/VALIDATION ENGINE (P2-2): bottom and full attribute tables store the same value for the same edit', () => {
// UNIT_FIELD_KINDS is the single source of truth both AttributeTable.tsx
// (bottom table) and FullAttributeTableModal.tsx consult for "which
// physical-unit conversion does this column need" -- previously the bottom
// table had no unit-conversion concept at all (it always stored the raw
// typed number verbatim, unlike the full table), so the same elevation/
// demand/length/diameter edit produced two different stored INP values
// depending on which table was used.
assert.equal(UNIT_FIELD_KINDS['elevation'], 'head');
assert.equal(UNIT_FIELD_KINDS['invertElev'], 'head');
assert.equal(UNIT_FIELD_KINDS['demand'], 'demand');
assert.equal(UNIT_FIELD_KINDS['length'], 'length');
assert.equal(UNIT_FIELD_KINDS['diameter'], 'diameter');
assert.equal(UNIT_FIELD_KINDS['id'], undefined, 'non-unit-bearing fields must have no conversion kind');
const usInp = `[TITLE]
US Unit Edit Parity Test
[JUNCTIONS]
J1 10 5 ;
[RESERVOIRS]
R1 50 ;
[PIPES]
P1 R1 J1 100 8 100 0 Open ;
[OPTIONS]
UNITS GPM
[END]
`;
const model = parseInp(usInp);
const sourceUnits = model.options.units;
// Both tables show/accept "30.5" as a Korean-display elevation in meters;
// both must convert to the SAME native (feet) value before storing.
const displayedElevation = 30.5;
const modelElevation = metersToLength(displayedElevation, sourceUnits);
const viaFullTable = updateNodeAttributes(model, 'J1', { elevation: modelElevation });
const viaBottomTable = updateNodeAttributes(model, 'J1', {
elevation: UNIT_FIELD_KINDS['elevation'] === 'head' ? metersToLength(displayedElevation, sourceUnits) : displayedElevation,
});
assert.equal(viaFullTable.nodes['J1'].elevation, viaBottomTable.nodes['J1'].elevation);
assert.ok(Math.abs(viaFullTable.nodes['J1'].elevation - displayedElevation * 3.280839895013123) < 1e-9);
// Same for pipe diameter: "250mm" must store as the same inches value
// regardless of which table the edit came from.
const displayedDiameterMm = 250;
const modelDiameter = millimetersToDiameter(displayedDiameterMm, sourceUnits);
const pipeViaFullTable = updatePipeAttributes(model, 'P1', { diameter: modelDiameter });
const pipeViaBottomTable = updatePipeAttributes(model, 'P1', {
diameter: UNIT_FIELD_KINDS['diameter'] === 'diameter' ? millimetersToDiameter(displayedDiameterMm, sourceUnits) : displayedDiameterMm,
});
assert.equal(pipeViaFullTable.pipes['P1'].diameter, pipeViaBottomTable.pipes['P1'].diameter);
// Exported INP must be byte-identical regardless of which table produced it.
assert.equal(generateInp(viaFullTable), generateInp(viaBottomTable));
assert.equal(generateInp(pipeViaFullTable), generateInp(pipeViaBottomTable));
});
test('68. GIS IMPORT SPATIAL INDEX (P2-5b): endpoint snapping at scale still finds the exact same matches as a full scan', () => {
// A long chain of 1500 connected segments (1501 shared endpoints) --
// large enough that an O(n^2) full-scan snap match would be meaningfully
// slow, and exactly the shape that most stresses a grid index (every
// consecutive segment's start must snap onto the previous one's end).
const CHAIN_LENGTH = 1500;
const features = [];
for (let i = 0; i < CHAIN_LENGTH; i++) {
features.push({
type: 'Feature',
properties: { FTR_IDN: `SEG${i}` },
geometry: {
type: 'LineString',
// Each segment's start exactly matches the previous segment's end;
// spaced widely (100 units apart in a planar/meter-projected space)
// so no two DIFFERENT chain vertices ever fall within the snap
// threshold of each other.
coordinates: [[i * 100, 0], [(i + 1) * 100, 0]],
},
});
}
const geojson = { type: 'FeatureCollection', features };
const start = performance.now();
const { model, summary } = buildNetworkFromGeoJSON(geojson as any, {
defaultDiameter: 200,
defaultRoughness: 120,
sourceHead: 60,
});
const elapsedMs = performance.now() - start;
// Exactly CHAIN_LENGTH + 1 distinct vertices -- every interior junction
// shared between two segments must have been correctly merged into one
// node, never duplicated.
assert.equal(Object.keys(model.nodes).length, CHAIN_LENGTH + 1);
assert.equal(summary.totalPipeCount, CHAIN_LENGTH);
// Every interior connection is an EXACT coordinate match (not fuzzy), so
// the spatial index must report zero fuzzy auto-snaps here.
assert.equal(summary.autoSnappedEndpointCount, 0);
// Sanity performance bound: a spatial index should comfortably finish this
// in well under a second; a full O(n^2) scan over 1500 segments would be
// orders of magnitude slower. Generous threshold to avoid CI flakiness.
assert.ok(elapsedMs < 5000, `expected sub-5s for spatially-indexed snapping, got ${elapsedMs.toFixed(0)}ms`);
});
test('69. COMPOUND CONDITION FILTER (P2-1): "pressure < 15 AND velocity > 2" style filters and saved selection sets', () => {
assert.equal(evaluateFilterCondition(10, '<', 15), true);
assert.equal(evaluateFilterCondition(15, '<', 15), false);
assert.equal(evaluateFilterCondition(15, '<=', 15), true);
assert.equal(evaluateFilterCondition(20, '>', 15), true);
assert.equal(evaluateFilterCondition(20, '>=', 20), true);
assert.equal(evaluateFilterCondition(20, '==', 20), true);
assert.equal(evaluateFilterCondition(20 + 1e-12, '==', 20), true, 'exact-equality tolerates float noise');
assert.equal(evaluateFilterCondition(21, '==', 20), false);
const rows = [
{ id: 'J1', pressure: 10, velocity: 3 }, // pressure<15 AND velocity>2 -> match
{ id: 'J2', pressure: 20, velocity: 3 }, // pressure not <15 -> no match
{ id: 'J3', pressure: 10, velocity: 1 }, // velocity not >2 -> no match
{ id: 'J4', pressure: 5, velocity: 5 }, // matches both
];
const conditions: FilterCondition[] = [
{ field: 'pressure', operator: '<', value: 15 },
{ field: 'velocity', operator: '>', value: 2 },
];
const matched = rows.filter((r) => rowMatchesAllConditions(r, conditions));
assert.deepEqual(matched.map((r) => r.id), ['J1', 'J4']);
// No conditions -> every row matches (an empty AND is vacuously true).
assert.equal(rows.filter((r) => rowMatchesAllConditions(r, [])).length, rows.length);
// A condition referencing a field the row doesn't have (or a non-numeric
// value) must exclude the row, never throw or silently pass.
const missingFieldRows = [{ id: 'X1', pressure: 10 }, { id: 'X2', pressure: 10, velocity: 'n/a' as unknown as number }];
const withMissingField = missingFieldRows.filter((r) =>
rowMatchesAllConditions(r, [{ field: 'velocity', operator: '>', value: 0 }])
);
assert.equal(withMissingField.length, 0);
});
test('70. PATH TO NEAREST SOURCE (P2-3): a worst-condition node auto-traces the upstream path to its water source', () => {
// R1 -> J1 -> J2 -> J3 (a straight chain) plus a red-herring branch J2->J4
// that must NOT appear in the shortest path from J3 back to R1.
const sampleInp = `[TITLE]
Path To Source Test
[JUNCTIONS]
J1 10 5 ;
J2 10 5 ;
J3 10 5 ;
J4 10 5 ;
[RESERVOIRS]
R1 50 ;
[PIPES]
P1 R1 J1 100 200 100 0 Open ;
P2 J1 J2 100 200 100 0 Open ;
P3 J2 J3 100 200 100 0 Open ;
P4 J2 J4 100 200 100 0 Open ;
[OPTIONS]
UNITS LPS
[END]
`;
const model = parseInp(sampleInp);
const path = findPathToNearestSource(model, 'J3');
assert.ok(path);
assert.deepEqual(path!.nodeIds, ['J3', 'J2', 'J1', 'R1']);
assert.deepEqual(path!.linkIds, ['P3', 'P2', 'P1']);
assert.ok(!path!.nodeIds.includes('J4'), 'the unrelated branch must not appear in the shortest path');
// The source node itself: trivial one-node path, no links.
const trivial = findPathToNearestSource(model, 'R1');
assert.deepEqual(trivial, { nodeIds: ['R1'], linkIds: [] });
// A nonexistent node, or a network with no source at all, must return null
// rather than throwing.
assert.equal(findPathToNearestSource(model, 'NOPE'), null);
const noSourceModel = { ...model, nodes: Object.fromEntries(Object.entries(model.nodes).map(([id, n]) => [id, { ...n, type: n.type === 'RESERVOIR' ? 'JUNCTION' as const : n.type }])) };
assert.equal(findPathToNearestSource(noSourceModel, 'J3'), null);
// A node with no path to any source (disconnected cluster, mirroring the
// P1-5 isolated-cluster scenario) must also return null, not throw or find
// a phantom path.
const disconnectedInp = `[TITLE]
Disconnected Test
[JUNCTIONS]
J1 10 5 ;
J2 10 5 ;
[RESERVOIRS]
R1 50 ;
[PIPES]
P1 J1 J2 100 200 100 0 Open ;
[OPTIONS]
UNITS LPS
[END]
`;
const disconnectedModel = parseInp(disconnectedInp);
assert.equal(findPathToNearestSource(disconnectedModel, 'J1'), null);
});
test('71. SCENARIO COMPARISON METRICS (P2-4): common per-scenario summary stats match a hand-computed baseline', () => {
const sampleInp = `[TITLE]
Scenario Metrics Test
[JUNCTIONS]
J1 10 5 ;
J2 10 15 ;
[RESERVOIRS]
R1 50 ;
[PIPES]
P1 R1 J1 100 200 100 0 Open ;
P2 J1 J2 100 200 100 0 Open ;
[OPTIONS]
UNITS LPS
[END]
`;
const model = parseInp(sampleInp);
const fakeResult = {
engine: { runtime: 'wasm', version: '2.3.5' },
timeSeconds: 0,
units: { flow: 'LPS', pressure: 'm' },
nodes: {
J1: { id: 'J1', type: 0, coordinates: null, demand: 5, head: 40, pressure: 30 },
J2: { id: 'J2', type: 0, coordinates: null, demand: 15, head: 35, pressure: 25 },
R1: { id: 'R1', type: 1, coordinates: null, demand: 0, head: 50, pressure: 0 },
},
links: {
P1: { id: 'P1', type: 1, fromNode: 'R1', toNode: 'J1', vertices: [], flow: 20, velocity: 0.7, headloss: 10 },
P2: { id: 'P2', type: 1, fromNode: 'J1', toNode: 'J2', vertices: [], flow: 15, velocity: 1.3, headloss: 5 },
},
reportText: '',
} as unknown as SimulationResult;
const metrics = computeScenarioMetrics(model, fakeResult);
// Total demand comes from the MODEL's junction demands (5 + 15 = 20),
// independent of whatever the result reports.
assert.equal(metrics.totalDemand, 20);
// Junctions only: the reservoir's always-0 "pressure" must not become the
// network minimum (RES-1).
assert.equal(metrics.minPressure, 25, 'reservoir pressure (0) must be excluded');
assert.equal(metrics.maxPressure, 30);
assert.ok(Math.abs(metrics.avgPressure - (30 + 25) / 2) < 1e-9);
assert.equal(metrics.minVelocity, 0.7);
assert.equal(metrics.maxVelocity, 1.3);
assert.ok(Math.abs(metrics.avgVelocity - (0.7 + 1.3) / 2) < 1e-9);
// Empty result (no nodes/links at all) must not throw or divide by zero.
const emptyMetrics = computeScenarioMetrics(model, {
...fakeResult,
nodes: {},
links: {},
} as unknown as SimulationResult);
assert.equal(emptyMetrics.minPressure, 0);
assert.equal(emptyMetrics.maxVelocity, 0);
assert.equal(emptyMetrics.totalDemand, 20, 'total demand still comes from the model regardless of the result');
});
Reference in new issue View Git Blame Copy Permalink