493 lines
21 KiB
Python
493 lines
21 KiB
Python
from test_est_rea_parity import run
|
|
|
|
|
|
def test_print_margins_validate_independently_and_keep_legacy_setting():
|
|
result = run(
|
|
"math",
|
|
"""(()=>{
|
|
const p=EstNative.empty(); p.printSettings={margin:10,marginTop:11,marginBottom:12,marginLeft:13,marginRight:14};
|
|
const valid=EstModel.validate(p).printSettings; let rejected=0;
|
|
for (const key of ['marginTop','marginBottom','marginLeft','marginRight']) {
|
|
const q=structuredClone(p);q.printSettings[key]=51;try{EstModel.validate(q)}catch{rejected++}
|
|
}
|
|
return {valid,rejected};
|
|
})()""",
|
|
)
|
|
assert result["valid"] == {
|
|
"margin": 10,
|
|
"marginTop": 11,
|
|
"marginBottom": 12,
|
|
"marginLeft": 13,
|
|
"marginRight": 14,
|
|
}
|
|
assert result["rejected"] == 4
|
|
|
|
|
|
def test_custom_print_form_documents_are_saved_and_unknown_keys_rejected():
|
|
result = run(
|
|
"math",
|
|
"""(()=>{
|
|
const p=EstNative.empty();p.documents={'annual-items':'stage note','progress-costs':'progress note','standard-usage':'standard note'};
|
|
const valid=EstModel.validate(p).documents;let rejected=false;
|
|
const q=EstNative.empty();q.documents={'invalid-key':'bad'};try{EstModel.validate(q)}catch{rejected=true}
|
|
return {valid,rejected};
|
|
})()""",
|
|
)
|
|
assert result["valid"] == {
|
|
"annual-items": "stage note",
|
|
"progress-costs": "progress note",
|
|
"standard-usage": "standard note",
|
|
}
|
|
assert result["rejected"]
|
|
|
|
|
|
def test_schedule_refreshes_progress_from_latest_locked_round_without_losing_dates():
|
|
result = run(
|
|
"math",
|
|
"""(()=>{
|
|
const p=EstNative.empty();p.tables.EstMainDat=[{PkID:1,Code:'A',GN:10},{PkID:2,Code:'B',GN:0}];
|
|
p.schedule=[{id:'a',SourceKey:'id:1',Code:'A',Name:'work',start:'2026-01-01',end:'2026-02-01',weight:100,progress:10},
|
|
{id:'b',SourceKey:'id:2',Code:'B',Name:'zero',start:'',end:'',weight:0,progress:40},
|
|
{id:'c',Code:'X',Name:'manual',start:'',end:'',weight:10,progress:20}];
|
|
p.progress=[{id:'one',locked:true,result:{rows:[{PkID:1,Code:'A',GN:10,TotalGN:2}]}},
|
|
{id:'two',locked:true,result:{rows:[{PkID:1,Code:'A',GN:10,TotalGN:3},{PkID:2,Code:'B',GN:0,TotalGN:0}]}}];
|
|
const before=JSON.stringify(p), updated=EstSchedule.refreshProgress(p);let bad=0;
|
|
p.progress[1].result.rows[0].TotalGN=11;try{EstSchedule.refreshProgress(p)}catch{bad++}
|
|
p.progress=[];try{EstSchedule.refreshProgress(p)}catch{bad++}
|
|
return {updated,bad,unchanged:JSON.parse(before).schedule};
|
|
})()""",
|
|
)
|
|
assert [row["progress"] for row in result["updated"]] == [30, 40, 20]
|
|
assert result["updated"][0]["start"] == "2026-01-01"
|
|
assert result["updated"][0]["weight"] == 100
|
|
assert result["unchanged"][0]["progress"] == 10
|
|
assert result["bad"] == 2
|
|
|
|
|
|
def test_annual_print_contains_each_stage_and_calculation_errors():
|
|
result = run(
|
|
"math",
|
|
"""(()=>{
|
|
const p=EstNative.empty();p.options.SourceRefresh=false;
|
|
p.tables.EstMainDat=[{PkID:1,Code:'R',GN:3,GU:100},{LinkIndex:54}];
|
|
p.annual=[{name:'first',formula:'[기준]*0.25'},{name:'second',formula:'[기준]-[first]'}];
|
|
const q=EstNative.calculate(p), good=EstForms.data('annual-summary',q), items=EstForms.data('annual-items',q);
|
|
q.annual[0].formula='[unknown]';
|
|
return {good,items,bad:EstForms.data('annual-summary',q),badItems:EstForms.data('annual-items',q)};
|
|
})()""",
|
|
)
|
|
assert [row["directCost"] for row in result["good"]["rows"]] == [75, 225]
|
|
assert result["good"]["rows"][1]["formula"] == "[기준]-[first]"
|
|
assert result["good"]["errors"] == []
|
|
assert result["bad"]["errors"]
|
|
assert [row["stage"] for row in result["items"]["rows"]] == ["first", "second"]
|
|
assert [row["TC"] for row in result["items"]["rows"]] == [75, 225]
|
|
assert result["badItems"]["errors"]
|
|
|
|
|
|
def test_progress_and_escalation_print_use_selected_calculations():
|
|
result = run(
|
|
"math",
|
|
"""(()=>{
|
|
const p=EstNative.empty();p.options.SourceRefresh=false;p.options.EscDesignTotal=1000;
|
|
p.tables.EstMainDat=[{PkID:1,Code:'R',Name:'work',GN:10,GU:100,AGU:100,EscActual:3},{LinkIndex:54}];
|
|
p.progress=[{id:'one',name:'first',inputs:{'1':{Gum:2}}}];
|
|
const q=EstProgress.lock(EstNative.calculate(p),'one');
|
|
q.tables.EstMainDat[0].GU=200;
|
|
q.progress.push({id:'two',name:'second',inputs:{'1':{Gum:3}}});
|
|
return {locked:EstForms.data('progress-summary',q,{roundId:'one'}),
|
|
draft:EstForms.data('progress-summary',q,{roundId:'two'}),
|
|
escalation:EstForms.data('escalation-summary',p),
|
|
empty:EstForms.data('progress-summary',EstNative.empty())};
|
|
})()""",
|
|
)
|
|
assert result["locked"]["rows"][0]["GumTC"] == 200
|
|
assert result["locked"]["rows"][0]["GU"] == 100
|
|
assert result["draft"]["rows"][0]["GumTC"] == 600
|
|
assert result["draft"]["rows"][0]["TotalTC"] == 800
|
|
assert result["escalation"]["rows"][0]["EscExcluded"] == 3
|
|
assert result["escalation"]["rows"][0]["EscApplied"] == 7
|
|
assert result["empty"]["errors"]
|
|
|
|
|
|
def test_progress_cost_print_preserves_selected_round_costs():
|
|
result = run(
|
|
"math",
|
|
"""(()=>{
|
|
const p=EstNative.empty();p.options.SourceRefresh=false;
|
|
p.tables.EstMainDat=[{PkID:1,Code:'R',GN:10,GU:100},{LinkIndex:54}];
|
|
p.tables.Wonga=[{Gubun:'D',Name:'direct',BaseField:'GC'},{Gubun:'T',Name:'total',LinkIndex:55,VSusic:'D'}];
|
|
p.progress=[{id:'one',inputs:{'1':{Gum:2,Sa:1}},approved:true}];
|
|
const q=EstProgress.lock(EstNative.calculate(p),'one');
|
|
q.tables.EstMainDat[0].GU=200;q.progress.push({id:'two',inputs:{'1':{Gum:3}}});
|
|
return {one:EstForms.data('progress-costs',q,{roundId:'one'}),two:EstForms.data('progress-costs',q,{roundId:'two'})};
|
|
})()""",
|
|
)
|
|
assert result["one"]["rows"][-1]["ContractCost"] == 1000
|
|
assert result["one"]["rows"][-1]["GumCost"] == 200
|
|
assert result["one"]["rows"][-1]["SaCost"] == 100
|
|
assert result["two"]["rows"][-1]["JunCost"] == 100
|
|
assert result["two"]["rows"][-1]["GumCost"] == 600
|
|
assert result["two"]["rows"][-1]["TotalCost"] == 700
|
|
|
|
|
|
def test_escalation_cost_print_uses_computed_cost_breakdowns():
|
|
result = run(
|
|
"math",
|
|
"""(()=>{
|
|
const p=EstNative.empty();p.options.SourceRefresh=false;p.options.EscDesignTotal=1000;
|
|
p.tables.EstMainDat=[{PkID:1,Code:'R',GN:10,GU:80},{LinkIndex:54}];
|
|
p.tables.Wonga=[{Gubun:'D',Name:'direct',BaseField:'GC'},{Gubun:'T',Name:'total',LinkIndex:55,VSusic:'D'}];
|
|
const q=EstBusiness.baseline(EstNative.calculate(p));
|
|
Object.assign(q.tables.EstMainDat[0],{AGU:100,GU:120,EscActual:3});
|
|
return EstForms.data('escalation-costs',q);
|
|
})()""",
|
|
)
|
|
assert result["errors"] == []
|
|
assert result["rows"][-1]["ContractCost"] == 800
|
|
assert result["rows"][-1]["adjustedCost"] == 960
|
|
assert result["rows"][-1]["excludedCost"] == 240
|
|
|
|
|
|
def test_resource_view_filtering_and_by_work_expansion():
|
|
result = run(
|
|
"math",
|
|
"""(()=>{
|
|
const p = structuredClone(project);
|
|
const allRows = EstResources.calculate(p, false).rows;
|
|
const byWorkRows = EstResources.calculate(p, true).rows;
|
|
|
|
const laborOnly = allRows.filter(r => r.kind === 6);
|
|
const materialOnly = allRows.filter(r => r.kind === 5);
|
|
const machineOnly = allRows.filter(r => r.kind === 105);
|
|
|
|
const laborByWork = byWorkRows.filter(r => r.kind === 6);
|
|
|
|
// 공종별 집계 합산과 전체 집계의 금액/수량 일치 검증
|
|
const laborAllQty = laborOnly.reduce((s, r) => s + r.quantity, 0);
|
|
const laborAllAmt = laborOnly.reduce((s, r) => s + r.amount, 0);
|
|
const laborWorkQty = laborByWork.reduce((s, r) => s + r.quantity, 0);
|
|
const laborWorkAmt = laborByWork.reduce((s, r) => s + r.amount, 0);
|
|
|
|
// 서식 데이터(EstForms.data) 연동 확인
|
|
const f112 = EstForms.data(112, p, {project: p});
|
|
const f13 = EstForms.data(13, p, {project: p});
|
|
|
|
return {
|
|
allCount: allRows.length,
|
|
byWorkCount: byWorkRows.length,
|
|
laborCount: laborOnly.length,
|
|
materialCount: materialOnly.length,
|
|
machineCount: machineOnly.length,
|
|
laborByWorkCount: laborByWork.length,
|
|
qtyDiff: Math.abs(laborAllQty - laborWorkQty),
|
|
amtDiff: Math.abs(laborAllAmt - laborWorkAmt),
|
|
f112Count: f112.rows.length,
|
|
f13Count: f13.rows.length,
|
|
f112HasWork: f112.columns.includes('WorkCode') && f112.columns.includes('WorkName')
|
|
};
|
|
})()""",
|
|
)
|
|
assert result["allCount"] == 27
|
|
assert result["byWorkCount"] == 72
|
|
assert result["laborCount"] == 7
|
|
assert result["materialCount"] == 13
|
|
assert result["machineCount"] == 7
|
|
assert result["laborByWorkCount"] == 30
|
|
assert result["qtyDiff"] < 1e-9
|
|
assert result["amtDiff"] < 1e-6
|
|
assert result["f112Count"] == 30
|
|
assert result["f13Count"] == 7
|
|
assert result["f112HasWork"] is True
|
|
|
|
|
|
def test_resource_report_separates_each_work_item_without_changing_aggregate():
|
|
result = run(
|
|
"math",
|
|
"""(()=>{
|
|
const p=EstNative.empty();p.options.SourceRefresh=false;
|
|
p.tables.StuffcDat=[{Code:'M',Name:'material',InputTC:100,ValueIndex:4}];
|
|
p.tables.EstMainDat=[{PkID:1,Code:'M',LinkIndex:5,GN:2,GU:100},{PkID:2,Code:'M',LinkIndex:5,GN:3,GU:100},{LinkIndex:54}];
|
|
return {all:EstResources.calculate(p),split:EstResources.calculate(p,true)};
|
|
})()""",
|
|
)
|
|
assert len(result["all"]["rows"]) == 1
|
|
assert len(result["split"]["rows"]) == 2
|
|
assert (
|
|
sum(r["quantity"] for r in result["split"]["rows"])
|
|
== result["all"]["rows"][0]["quantity"]
|
|
== 5
|
|
)
|
|
assert (
|
|
sum(r["amount"] for r in result["split"]["rows"])
|
|
== result["all"]["rows"][0]["amount"]
|
|
== 500
|
|
)
|
|
|
|
|
|
def test_schedule_dates_ranges_and_weighted_user_progress():
|
|
result = run(
|
|
"math",
|
|
"""(()=>{
|
|
const p=EstNative.empty();p.schedule=[
|
|
{id:'a',Code:'A',Name:'first',start:'2026-11-01',end:'2026-11-05',weight:100,progress:25},
|
|
{id:'b',Code:'B',Name:'second',start:'2026-11-06',end:'2026-11-10',weight:300,progress:50}];
|
|
const valid=EstSchedule.calculate(p),bad=[];
|
|
for(const change of [{start:'2026-02-30'},{progress:101},{weight:-1},{end:'2026-10-01'}]) {
|
|
const q=structuredClone(p);Object.assign(q.schedule[0],change);
|
|
try{EstModel.validate(q);bad.push(false)}catch{bad.push(true)}
|
|
}
|
|
return {valid,bad};
|
|
})()""",
|
|
)
|
|
assert result["valid"]["progress"] == 43.75
|
|
assert result["valid"]["rows"][0]["width"] == 50
|
|
assert result["valid"]["rows"][1]["left"] == 50
|
|
assert result["bad"] == [True] * 4
|
|
|
|
|
|
def test_schedule_import_and_update_weights_preserve_user_schedule():
|
|
result = run(
|
|
"math",
|
|
"""(()=>{
|
|
const p=EstNative.empty();
|
|
p.tables.EstMainDat=[{Code:'A',Name:'one',TC:100}, {Code:'B',Name:'two',TC:300},
|
|
{Code:'HEADER',Level:1,TC:999},{Code:'TOTAL',LinkIndex:54,TC:400}];
|
|
p.schedule=[{id:'old',Code:'A',Name:'custom',start:'2026-01-01',end:'2026-01-10',weight:1,progress:40},
|
|
{id:'manual',Code:'other',Name:'manual',start:'',end:'',weight:5,progress:20}];
|
|
let id=0;const added=EstSchedule.fromEstimate(p,()=>String(++id));p.schedule.push(...added);
|
|
p.tables.EstMainDat[0].TC=200;p.schedule=EstSchedule.refreshWeights(p);
|
|
let duplicate='';p.tables.EstMainDat.push({Code:'A',TC:20});
|
|
try{EstSchedule.fromEstimate(p,()=>String(++id))}catch(e){duplicate=e.message}
|
|
return {added,rows:p.schedule,duplicate};
|
|
})()""",
|
|
)
|
|
assert [row["Code"] for row in result["added"]] == ["B"]
|
|
assert [row["weight"] for row in result["rows"]] == [200, 5, 300]
|
|
assert result["rows"][0]["Name"] == "custom"
|
|
assert result["rows"][0]["start"] == "2026-01-01"
|
|
assert result["rows"][0]["progress"] == 40
|
|
assert result["duplicate"]
|
|
|
|
|
|
def test_schedule_imports_distinct_rows_with_repeated_or_empty_codes():
|
|
result = run(
|
|
"math",
|
|
"""(()=>{
|
|
const p=EstNative.empty();p.tables.EstMainDat=[
|
|
{PkID:1,Code:'X',Name:'one',TC:100},{PkID:2,Code:'X',Name:'two',TC:200},
|
|
{PkID:3,Code:null,Name:'three',TC:300}];
|
|
let id=0;p.schedule=EstSchedule.fromEstimate(p,()=>String(++id));
|
|
p.schedule[0].start='2026-01-01';p.schedule[0].progress=50;
|
|
p.tables.EstMainDat.reverse();p.tables.EstMainDat[0].TC=400;
|
|
const updated=EstSchedule.refreshWeights(p);
|
|
return {rows:p.schedule,updated,again:EstSchedule.fromEstimate(p,()=>String(++id))};
|
|
})()""",
|
|
)
|
|
assert [row["SourceKey"] for row in result["rows"]] == ["id:1", "id:2", "id:3"]
|
|
assert [row["weight"] for row in result["updated"]] == [100, 200, 400]
|
|
assert result["updated"][0]["start"] == "2026-01-01"
|
|
assert result["updated"][0]["progress"] == 50
|
|
assert result["again"] == []
|
|
|
|
|
|
def test_schedule_move_row_and_clear_operations():
|
|
result = run(
|
|
"math",
|
|
"""(()=>{
|
|
const p = EstNative.empty();
|
|
p.schedule = [
|
|
{id:'1', Code:'A', Name:'첫번째', start:'2026-01-01', end:'2026-01-10', weight:100, progress:10},
|
|
{id:'2', Code:'B', Name:'두번째', start:'2026-01-11', end:'2026-01-20', weight:200, progress:20},
|
|
{id:'3', Code:'C', Name:'세번째', start:'2026-01-21', end:'2026-01-31', weight:300, progress:30}
|
|
];
|
|
|
|
// 상하 경계 이동 무반응 확인
|
|
EstSchedule.moveRow(p, 0, -1);
|
|
const atTop = p.schedule.map(r => r.Code);
|
|
|
|
EstSchedule.moveRow(p, 2, 1);
|
|
const atBottom = p.schedule.map(r => r.Code);
|
|
|
|
// 중간 행 아래로 이동
|
|
EstSchedule.moveRow(p, 1, 1);
|
|
const afterDown = p.schedule.map(r => r.Code);
|
|
|
|
// 마지막 행 위로 이동
|
|
EstSchedule.moveRow(p, 2, -1);
|
|
const afterUp = p.schedule.map(r => r.Code);
|
|
|
|
// 공정 전체 비우기
|
|
const countBeforeClear = p.schedule.length;
|
|
EstSchedule.clearSchedule(p);
|
|
const countAfterClear = p.schedule.length;
|
|
|
|
return {
|
|
atTop,
|
|
atBottom,
|
|
afterDown,
|
|
afterUp,
|
|
countBeforeClear,
|
|
countAfterClear
|
|
};
|
|
})()""",
|
|
)
|
|
assert result["atTop"] == ["A", "B", "C"]
|
|
assert result["atBottom"] == ["A", "B", "C"]
|
|
assert result["afterDown"] == ["A", "C", "B"]
|
|
assert result["afterUp"] == ["A", "B", "C"]
|
|
assert result["countBeforeClear"] == 3
|
|
assert result["countAfterClear"] == 0
|
|
|
|
|
|
def test_quantity_print_includes_manual_and_sheet_formulas_and_errors():
|
|
result = run(
|
|
"math",
|
|
"""(()=>{
|
|
const p=EstNative.empty();p.quantities=[
|
|
{Code:'A',Name:'first',formula:'2',TargetCode:'X'},
|
|
{Code:'B',Name:'second',formula:'[A]*3',TargetCode:'X'},
|
|
{Code:'C',Name:'bad',formula:'[missing]',TargetCode:'X'}];
|
|
p.quantitySheets=[{Code:'Q',Name:'sheet',options:{},rows:[
|
|
{LineData:'4+5 = \\x120\\x12',markers:['r1']}],
|
|
items:[{Code:'r1',Name:'sheet item',GN:0,TargetCode:'Y'}]}];
|
|
return EstForms.data(14,p);
|
|
})()""",
|
|
)
|
|
assert [row["GN"] for row in result["rows"]] == [2, 6, None, 9]
|
|
assert result["rows"][1]["formula"] == "[A]*3"
|
|
assert "4+5" in result["rows"][3]["formula"]
|
|
assert result["rows"][3]["TargetCode"] == "Y"
|
|
assert result["rows"][2]["Error"]
|
|
assert result["errors"]
|
|
|
|
|
|
def test_public_view_forms_print_gong_method_options():
|
|
result = run(
|
|
"math",
|
|
"""(()=>{
|
|
const p = EstNative.empty();
|
|
p.tables.EstMainDat = [
|
|
{ PkID: 1, Level: 1, Code: 'C01', Name: '토공사' },
|
|
{ PkID: 2, Level: 0, Code: 'A01', Name: '터파기', Size: '일반', Unite: 'm3', GN: 100, TU: 500, TC: 50000, NC: 20000, GC: 30000, JC: 0, SC: 0 }
|
|
];
|
|
p.tables.HeadMainDat = [
|
|
{ Index: 1, Code: 'H01', Name: '터파기 호표', TC: 500 },
|
|
{ Index: 0, Code: 'L01', Name: '인부', Unite: '인', GN: 0.1, NU: 1000, GU: 0, JU: 0, SU: 0, TC: 100 }
|
|
];
|
|
|
|
// 1) 기본(PrintGongMethod=0): 공람용 내역서(117), 일위대가(115), 총괄표(116, 118) 수량만/금액제외
|
|
p.printSettings = { PrintGongMethod: 0 };
|
|
const d117_m0 = EstForms.data(117, p);
|
|
const d115_m0 = EstForms.data(115, p);
|
|
const d118_m0 = EstForms.data(118, p);
|
|
const d116_m0 = EstForms.data(116, p);
|
|
|
|
// 2) PrintGongMethod=1: 단가/금액만 (수량 제외)
|
|
p.printSettings = { PrintGongMethod: 1 };
|
|
const d117_m1 = EstForms.data(117, p);
|
|
const d115_m1 = EstForms.data(115, p);
|
|
|
|
// 3) PrintGongMethod=2: 수량 + 단가/금액 모두 포함
|
|
p.printSettings = { PrintGongMethod: 2 };
|
|
const d117_m2 = EstForms.data(117, p);
|
|
const d115_m2 = EstForms.data(115, p);
|
|
const d118_m2 = EstForms.data(118, p);
|
|
|
|
// 4) 표준 내역서(1) 및 일위대가(2)는 공람옵션 영향 없이 전체 열 출력
|
|
const d1 = EstForms.data(1, p);
|
|
const d2 = EstForms.data(2, p);
|
|
|
|
return {
|
|
d117_m0: d117_m0.columns,
|
|
d115_m0: d115_m0.columns,
|
|
d118_m0: d118_m0.columns,
|
|
d116_m0: d116_m0.columns,
|
|
d117_m1: d117_m1.columns,
|
|
d115_m1: d115_m1.columns,
|
|
d117_m2: d117_m2.columns,
|
|
d115_m2: d115_m2.columns,
|
|
d118_m2: d118_m2.columns,
|
|
d1: d1.columns,
|
|
d2: d2.columns
|
|
};
|
|
})()""",
|
|
)
|
|
# 1) m0 (수량만): GN만 포함, 단가/금액 비목 제외
|
|
assert (
|
|
"GN" in result["d117_m0"]
|
|
and "TC" not in result["d117_m0"]
|
|
and "TU" not in result["d117_m0"]
|
|
)
|
|
assert (
|
|
"GN" in result["d115_m0"]
|
|
and "TC" not in result["d115_m0"]
|
|
and "NU" not in result["d115_m0"]
|
|
)
|
|
assert "TC" not in result["d118_m0"] and "NC" not in result["d118_m0"]
|
|
assert "TC" not in result["d116_m0"] and "NC" not in result["d116_m0"]
|
|
|
|
# 2) m1 (단가만): GN 제외, 단가/금액 포함
|
|
assert "GN" not in result["d117_m1"] and "TC" in result["d117_m1"] and "TU" in result["d117_m1"]
|
|
assert "GN" not in result["d115_m1"] and "TC" in result["d115_m1"] and "NU" in result["d115_m1"]
|
|
|
|
# 3) m2 (수량, 단가 모두): GN, 단가, 금액 모두 포함
|
|
assert "GN" in result["d117_m2"] and "TC" in result["d117_m2"]
|
|
assert "GN" in result["d115_m2"] and "TC" in result["d115_m2"]
|
|
assert "TC" in result["d118_m2"]
|
|
|
|
# 4) 일반 서식(1, 2)은 불변 유지
|
|
assert "GN" in result["d1"] and "TC" in result["d1"]
|
|
assert "GN" in result["d2"] and "TC" in result["d2"]
|
|
|
|
|
|
def test_print_apply_field_and_sum_bottom_preserve_all_rows_and_no_destructive_filtering():
|
|
result = run(
|
|
"math",
|
|
"""(()=>{
|
|
const p = EstNative.empty();
|
|
// 공종(레벨1), 소계, 0원 항목, 음수 변경분, 일반 상세항목 혼재
|
|
p.tables.EstMainDat = [
|
|
{ Code: "", Name: "토공사", Size: "", Unite: "", GN: 0, TU: 0, TC: 0, Level: 1 },
|
|
{ Code: "A01", Name: "터파기", Size: "토사", Unite: "m3", GN: 100, TU: 5000, TC: 500000, NC: 300000, GC: 100000, JC: 100000, SC: 0, Level: 0 },
|
|
{ Code: "A02", Name: "잔토처리", Size: "덤프15t", Unite: "m3", GN: 50, TU: 0, TC: 0, NC: 0, GC: 0, JC: 0, SC: 0, Level: 0 },
|
|
{ Code: "A03", Name: "설계변경감소", Size: "규격", Unite: "식", GN: -10, TU: 10000, TC: -100000, NC: -50000, GC: -50000, JC: 0, SC: 0, Level: 0 },
|
|
{ Code: "", Name: "소계", Size: "", Unite: "", GN: 0, TU: 0, TC: 400000, Level: 0 }
|
|
];
|
|
p.tables.HeadMainDat = [
|
|
{ Code: "H01", Name: "일위대가항목", Size: "", Unite: "식", GN: 1, NU: 1000, GU: 2000, JU: 0, SU: 0, TC: 3000 },
|
|
{ Code: "H02", Name: "0원대가항목", Size: "", Unite: "", GN: 1, NU: 0, GU: 0, JU: 0, SU: 0, TC: 0 }
|
|
];
|
|
|
|
// PrintApplyField / PrintSumBottom 옵션이 어떤 값이든 행과 제목·0원·음수 행이 삭제되지 않고 100% 보존되는지 확인
|
|
p.printSettings = { PrintApplyField: 1, PrintSumBottom: 1 };
|
|
const d1 = EstForms.data(1, p);
|
|
const d2 = EstForms.data(2, p);
|
|
const d117 = EstForms.data(117, p);
|
|
const d115 = EstForms.data(115, p);
|
|
|
|
const grid1 = EstForms.grid(d1);
|
|
|
|
return {
|
|
d1Count: d1.rows.length,
|
|
d2Count: d2.rows.length,
|
|
d117Count: d117.rows.length,
|
|
d115Count: d115.rows.length,
|
|
hasZeroRow: d1.rows.some(r => r.Code === "A02" && r.TU === 0),
|
|
hasNegativeRow: d1.rows.some(r => r.Code === "A03" && r.TC === -100000),
|
|
hasTitleRow: d1.rows.some(r => r.Name === "토공사" && r.Level === 1),
|
|
hasSubtotalRow: d1.rows.some(r => r.Name === "소계"),
|
|
noInvalidSumBottomTfoot: !grid1.includes("<tfoot>")
|
|
};
|
|
})()""",
|
|
)
|
|
assert result["d1Count"] == 5
|
|
assert result["d2Count"] == 2
|
|
assert result["d117Count"] == 5
|
|
assert result["d115Count"] == 2
|
|
assert result["hasZeroRow"] is True
|
|
assert result["hasNegativeRow"] is True
|
|
assert result["hasTitleRow"] is True
|
|
assert result["hasSubtotalRow"] is True
|
|
assert result["noInvalidSumBottomTfoot"] is True
|