618 lines
31 KiB
JavaScript
618 lines
31 KiB
JavaScript
"use strict";
|
|
|
|
const assert = require("node:assert/strict");
|
|
const fs = require("node:fs");
|
|
const path = require("node:path");
|
|
const test = require("node:test");
|
|
|
|
const manualFinancialUiModule = require("../../Web/manual-financial-ui.js");
|
|
const manualFinancialWorkflow = require("../../Web/manual-financial-workflow.js");
|
|
const manualListsUiModule = require("../../Web/manual-lists-ui.js");
|
|
const manualListsWorkflow = require("../../Web/manual-lists-workflow.js");
|
|
|
|
const repositoryRoot = path.resolve(__dirname, "..", "..");
|
|
const read = relativePath => fs.readFileSync(path.join(repositoryRoot, relativePath), "utf8");
|
|
const appHost = read("App.xaml.cs");
|
|
const app = read("Web/app.js");
|
|
const index = read("Web/index.html");
|
|
const styles = read("Web/styles.css");
|
|
const manualFinancialUi = read("Web/manual-financial-ui.js");
|
|
const mainWindow = read("MainWindow.xaml.cs");
|
|
const closeConfirmationBridge = read("MainWindow.CloseConfirmation.cs");
|
|
const manualFinancialBridge = read("MainWindow.ManualFinancial.cs");
|
|
const manualListsBridge = read("MainWindow.ManualLists.cs");
|
|
const namedPlaylistBridge = read("MainWindow.NamedPlaylists.cs");
|
|
const operatorCatalogBridge = read("MainWindow.OperatorCatalogs.cs");
|
|
const playoutBridge = read("MainWindow.Playout.cs");
|
|
const operatorMutationGate = read("src/MBN_STOCK_WEBVIEW.Core/Playout/OperatorMutationGate.cs");
|
|
|
|
function functionBody(source, name, nextName) {
|
|
const start = source.indexOf(`function ${name}(`);
|
|
assert.ok(start >= 0, `${name} must exist`);
|
|
const end = nextName ? source.indexOf(`function ${nextName}(`, start + 1) : source.length;
|
|
assert.ok(end > start, `${name} must precede ${nextName || "the end of the file"}`);
|
|
return source.slice(start, end);
|
|
}
|
|
|
|
function sliceBetween(source, startMarker, endMarker) {
|
|
const start = source.indexOf(startMarker);
|
|
const end = source.indexOf(endMarker, start + startMarker.length);
|
|
assert.ok(start >= 0, `${startMarker} must exist`);
|
|
assert.ok(end > start, `${endMarker} must follow ${startMarker}`);
|
|
return source.slice(start, end);
|
|
}
|
|
|
|
function assertOrdered(source, values) {
|
|
let previous = -1;
|
|
for (const value of values) {
|
|
const offset = source.indexOf(value);
|
|
assert.ok(offset >= 0, `${value} must be loaded`);
|
|
assert.ok(offset > previous, `${value} must preserve dependency order`);
|
|
assert.equal(source.indexOf(value, offset + value.length), -1, `${value} must be loaded once`);
|
|
previous = offset;
|
|
}
|
|
}
|
|
|
|
test("operator styles and scripts load once in dependency order before app.js", () => {
|
|
assertOrdered(index, [
|
|
'href="manual-lists-ui.css"',
|
|
'href="manual-financial-ui.css"',
|
|
'href="operator-catalog-ui.css"'
|
|
]);
|
|
assertOrdered(index, [
|
|
'src="manual-lists-workflow.js"',
|
|
'src="manual-financial-workflow.js"',
|
|
'src="operator-catalog-workflow.js"',
|
|
'src="manual-lists-ui.js"',
|
|
'src="manual-financial-ui.js"',
|
|
'src="operator-catalog-ui.js"',
|
|
'src="app.js"'
|
|
]);
|
|
});
|
|
|
|
test("the packaged app registers one primary instance before constructing any runtime", () => {
|
|
const register = appHost.indexOf("AppInstance.FindOrRegisterForKey(MainInstanceKey)");
|
|
const currentCheck = appHost.indexOf("if (!registeredInstance.IsCurrent)", register);
|
|
const redirect = appHost.indexOf("RedirectActivationToAsync(activation)", currentCheck);
|
|
const secondaryExit = appHost.indexOf("Exit();", redirect);
|
|
const windowConstruction = appHost.indexOf("_window = new MainWindow();", secondaryExit);
|
|
|
|
assert.ok(register >= 0);
|
|
assert.ok(currentCheck > register);
|
|
assert.ok(redirect > currentCheck);
|
|
assert.ok(secondaryExit > redirect);
|
|
assert.ok(windowConstruction > secondaryExit);
|
|
assert.match(appHost, /_mainInstance\.Activated \+= OnMainInstanceActivated/u);
|
|
assert.match(appHost,
|
|
/OnMainInstanceActivated\([\s\S]*DispatcherQueue\.TryEnqueue\(window\.Activate\)/u);
|
|
assert.doesNotMatch(appHost, /GetProcessesByName|Process\.Kill|Environment\.Exit/u);
|
|
});
|
|
|
|
test("legacy GraphE, FSell, VIList, ThemeA and EList controls open their real controllers", () => {
|
|
assert.match(index, /id="themeCatalogManageButton"/u);
|
|
assert.match(index, /id="expertCatalogManageButton"/u);
|
|
|
|
const fixedManual = functionBody(app, "openFixedManualAction", "addFixedAction");
|
|
assert.match(fixedManual,
|
|
/action\.builderKey === "s5025"[\s\S]*manualListsUi\?\.openNetSell\(action\.selection\?\.groupCode\)/u);
|
|
assert.match(fixedManual,
|
|
/action\.builderKey === "s5074"[\s\S]*action\.selection\?\.groupCode === "PAGED_VI"[\s\S]*manualListsUi\?\.openVi\(\)/u);
|
|
|
|
const stockRender = functionBody(app, "renderStockWorkflow", "requestStockSearch");
|
|
assert.match(stockRender, /for \(const action of operatorWorkflow\.manualStockActions\)/u);
|
|
assert.match(stockRender, /button\.disabled = !search\.selected \|\| operatorUiLocked\(\)/u);
|
|
assert.match(stockRender, /manualFinancialUi\?\.open\(action\)/u);
|
|
|
|
assert.match(app,
|
|
/themeCatalogManageButton\.addEventListener\("click", \(\) => \{[\s\S]*operatorCatalogUi\?\.openTheme\(context \|\| undefined\)/u);
|
|
assert.match(app,
|
|
/expertCatalogManageButton\.addEventListener\("click", \(\) => \{[\s\S]*operatorCatalogUi\?\.openExpert\(context \|\| undefined\)/u);
|
|
assert.match(app, /themeCatalogManageButton\.disabled = operatorUiLocked\(\)/u);
|
|
assert.match(app, /expertCatalogManageButton\.disabled = operatorUiLocked\(\)/u);
|
|
});
|
|
|
|
test("the original stock search and 31-cut surface stays independent of every business tab", () => {
|
|
const stockPanelStart = index.indexOf('<section class="panel stock-panel">');
|
|
const stockWorkflow = index.indexOf('id="stockWorkflow"', stockPanelStart);
|
|
const catalogPanelStart = index.indexOf('<section class="panel catalog-panel">', stockWorkflow);
|
|
assert.ok(stockPanelStart >= 0);
|
|
assert.ok(stockWorkflow > stockPanelStart);
|
|
assert.ok(catalogPanelStart > stockWorkflow);
|
|
assert.match(styles,
|
|
/\.console-grid\s*\{[^}]*grid-template-columns:\s*minmax\([^;]*minmax\([^;]*minmax\([^;]*minmax\(/u);
|
|
assert.match(styles,
|
|
/\.stock-panel \.stock-workflow\s*\{[^}]*flex:\s*1 1 auto/u);
|
|
|
|
const render = functionBody(app, "renderStockWorkflow", "requestStockSearch");
|
|
assert.match(render, /elements\.stockWorkflow\.hidden = false/u);
|
|
assert.doesNotMatch(render, /state\.activeMarket/u);
|
|
|
|
const binding = functionBody(app, "bindEvents", null);
|
|
assert.doesNotMatch(binding,
|
|
/industryWorkflow\.markets\.includes\(state\.activeMarket\)[\s\S]{0,160}state\.stockWorkflowCollapsed = true/u);
|
|
});
|
|
|
|
test("the original first overseas tab is the one and only initial market-data view", () => {
|
|
assert.match(index,
|
|
/<button class="nav-item active" data-market="overseas"><span>◉<\/span>해외<\/button>/u);
|
|
assert.match(index,
|
|
/<button class="nav-item" data-market="dashboard"><span>⌂<\/span>대시보드<\/button>/u);
|
|
assert.match(index, /<h1 id="workspaceTitle">해외 그래픽<\/h1>/u);
|
|
assert.match(app, /const state = \{\s*activeMarket: "overseas",/u);
|
|
|
|
const initialize = functionBody(app, "initialize", null);
|
|
assert.equal([...initialize.matchAll(/requestMarketData\(/gu)].length, 1);
|
|
assert.match(initialize, /requestMarketData\(state\.activeMarket\);/u);
|
|
assert.doesNotMatch(initialize, /requestMarketData\("(?:index|dashboard|foreign-stock)"\)/u);
|
|
|
|
const request = functionBody(app, "requestMarketData", "handleMarketData");
|
|
assert.match(request,
|
|
/postNative\("request-market-data", \{ requestId, view, maximumRowsPerTable: 250 \}\)/u);
|
|
});
|
|
|
|
test("the Web message allowlist has no unused external-open or reload command surface", () => {
|
|
assert.doesNotMatch(mainWindow, /case "open-external"/u);
|
|
assert.doesNotMatch(mainWindow, /case "reload"/u);
|
|
assert.doesNotMatch(app, /postNative\("open-external"/u);
|
|
assert.doesNotMatch(app, /postNative\("reload"/u);
|
|
});
|
|
|
|
test("first-routing consumes only messages owned by an operator controller", () => {
|
|
const nativeHandler = functionBody(app, "handleNativeMessage", "bindEvents");
|
|
const financialOffset = nativeHandler.indexOf("manualFinancialUi?.handleMessage");
|
|
const listsOffset = nativeHandler.indexOf("manualListsUi?.handleMessage");
|
|
const catalogOffset = nativeHandler.indexOf("operatorCatalogUi?.handleMessage");
|
|
const switchOffset = nativeHandler.indexOf("switch (message.type)");
|
|
assert.ok(financialOffset >= 0 && financialOffset < listsOffset);
|
|
assert.ok(listsOffset < catalogOffset && catalogOffset < switchOffset);
|
|
|
|
let id = 0;
|
|
const financial = manualFinancialUiModule.createController({
|
|
postNative() {},
|
|
appendPlaylistEntry() { return true; },
|
|
isLocked() { return false; },
|
|
getSelectedStock() { return null; },
|
|
showToast() {},
|
|
addLog() {},
|
|
createId() { id += 1; return `test-${id}`; }
|
|
});
|
|
const unownedFinancialTypes = [
|
|
manualFinancialWorkflow.bridgeContract.listResultType,
|
|
manualFinancialWorkflow.bridgeContract.listErrorType,
|
|
manualFinancialWorkflow.bridgeContract.loadResultType,
|
|
manualFinancialWorkflow.bridgeContract.loadErrorType,
|
|
"stock-search-results",
|
|
"stock-search-error",
|
|
manualFinancialWorkflow.bridgeContract.selectionResultType,
|
|
manualFinancialWorkflow.bridgeContract.selectionErrorType,
|
|
manualFinancialWorkflow.bridgeContract.mutationResultType,
|
|
manualFinancialWorkflow.bridgeContract.mutationErrorType,
|
|
manualFinancialWorkflow.bridgeContract.requestErrorType
|
|
];
|
|
for (const type of unownedFinancialTypes) {
|
|
assert.equal(financial.handleMessage(type, { requestId: "not-owned" }), false, type);
|
|
}
|
|
|
|
const lists = manualListsUiModule.createController({
|
|
postNative() {},
|
|
appendPlaylistEntry() { return true; },
|
|
isLocked() { return false; },
|
|
showToast() {},
|
|
addLog() {},
|
|
createId() { id += 1; return `test-${id}`; }
|
|
});
|
|
for (const type of [
|
|
manualListsWorkflow.bridgeContract.statusResultType,
|
|
manualListsWorkflow.bridgeContract.netSellDataType,
|
|
manualListsWorkflow.bridgeContract.netSellSaveResultType,
|
|
manualListsWorkflow.bridgeContract.viDataType,
|
|
manualListsWorkflow.bridgeContract.viSaveResultType,
|
|
manualListsWorkflow.bridgeContract.errorType,
|
|
"stock-search-results",
|
|
"stock-search-error"
|
|
]) {
|
|
assert.equal(lists.handleMessage(type, { requestId: "not-owned" }), false, type);
|
|
}
|
|
});
|
|
|
|
test("operator locks and trusted append checks cover every migrated manual surface", () => {
|
|
const lock = functionBody(app, "operatorUiLocked", "selectedStockForManualFinancial");
|
|
assert.match(lock, /isPlaylistSnapshotLocked\(\)/u);
|
|
assert.match(lock, /namedPlaylistBusy\(\)/u);
|
|
assert.match(lock, /state\.manualFinancialRestore\.entries\.size > 0/u);
|
|
|
|
const renderPlayout = functionBody(app, "renderPlayout", "clearPlayoutError");
|
|
for (const controller of ["manualListsUi", "manualFinancialUi", "operatorCatalogUi"]) {
|
|
assert.match(renderPlayout, new RegExp(`${controller}\\?\\.setLocked\\(operatorLocked\\)`));
|
|
}
|
|
|
|
const append = functionBody(app, "appendTrustedOperatorEntry", "isPlaylistSnapshotLocked");
|
|
assert.match(append, /if \(operatorUiLocked\(\)\) throw/u);
|
|
assert.match(append, /manualListsWorkflow\.restorePlaylistEntry\(entry\)/u);
|
|
assert.match(append, /manualListsWorkflow\.isPlaylistEntryPlayable\(entry\)/u);
|
|
assert.match(append, /manualFinancialWorkflow\.isPlaylistEntryPlayable\(entry\)/u);
|
|
assert.match(append,
|
|
/catalog\.find\(value => value\.builderKey === entry\.builderKey &&[\s\S]*sceneAliases\(value\)\.includes/u);
|
|
assert.match(append, /state\.playlist\.push\(entry\)/u);
|
|
assert.match(manualFinancialUi,
|
|
/if \(!workflow\.isPlaylistEntryPlayable\(entry\)\) throw new TypeError\("Untrusted entry\."\)/u);
|
|
});
|
|
|
|
test("named PLAY_LIST replacement admits manual rows only through live fresh-read trust", () => {
|
|
const trusted = functionBody(
|
|
app,
|
|
"isTrustedNamedPlaylistEntry",
|
|
"selectedNamedPlaylistDefinition");
|
|
assert.match(trusted,
|
|
/namedManualRestoreWorkflow\.isTrustedEntryForSave\(entry, itemIndex\)/u);
|
|
assert.match(trusted,
|
|
/guard && \(!guard\.trusted \|\| \(guard\.pageRecalculationRequired && !guard\.pageRecalculated\)\)/u);
|
|
|
|
const projection = functionBody(
|
|
app,
|
|
"namedLegacyFieldsForEntry",
|
|
"isTrustedNamedPlaylistEntry");
|
|
assert.match(projection, /namedManualRestoreWorkflow\.legacyFieldsForEntry\(entry, itemIndex\)/u);
|
|
assert.match(projection, /legacyNamedRowWorkflow\.legacySelectionForEntry\(entry\)/u);
|
|
assert.match(projection, /resolveNamedPlaylistRawRow\(/u);
|
|
assert.match(projection, /if \(!selection\)[\s\S]*throw new Error/u);
|
|
|
|
const replace = functionBody(
|
|
app,
|
|
"requestNamedPlaylistReplace",
|
|
"requestNamedPlaylistDelete");
|
|
assert.match(replace, /isTrustedEntry: isTrustedNamedPlaylistEntry/u);
|
|
assert.match(replace, /pageTextForEntry: namedPageTextForEntry/u);
|
|
assert.match(replace, /fieldsForEntry: namedLegacyFieldsForEntry/u);
|
|
assert.match(replace, /beginNamedPlaylistOperation\("replace", request/u);
|
|
});
|
|
|
|
test("local FSell and VI restores remain blocked until a correlated fresh read", () => {
|
|
const normalizeStored = functionBody(
|
|
app,
|
|
"normalizeStoredPlaylist",
|
|
"manualFinancialRestoreRecordForRequest");
|
|
assert.match(normalizeStored, /manualListsWorkflow\.restorePlaylistEntry\(item\)/u);
|
|
assert.match(normalizeStored,
|
|
/namedManualRestoreWorkflow\.createStoredManualListPending\([\s\S]*restoredManualListEntry,[\s\S]*itemIndex/u);
|
|
assert.match(normalizeStored,
|
|
/options\.manualFinancialRestores\.push\(pendingManualListEntry\)/u);
|
|
|
|
const install = functionBody(
|
|
app,
|
|
"installManualFinancialRestores",
|
|
"handleManualFinancialRestoreLoadResults");
|
|
assert.match(install, /isStoredManualListPending\(pending\)[\s\S]*"stored-list"/u);
|
|
|
|
const handler = functionBody(
|
|
app,
|
|
"handleNamedManualListResults",
|
|
"handleNamedManualListError");
|
|
assert.match(handler, /\["named-list", "stored-list"\]\.includes\(record\.restoreKind\)/u);
|
|
assert.match(handler,
|
|
/record\.restoreKind === "named-list"[\s\S]*trustNamedManualRestoration[\s\S]*matchesMaterializedEntry\(record\.pending, current\)/u);
|
|
|
|
const blocker = functionBody(app, "manualFinancialPrepareBlocked", "loadPlaylist");
|
|
assert.match(blocker,
|
|
/legacy-manual-lists-workflow[\s\S]*manualListsWorkflow\.isPlaylistEntryPlayable\(item\)/u);
|
|
});
|
|
|
|
test("named DB operations stay locked for the whole asynchronous manual restore", () => {
|
|
const busy = functionBody(app, "namedPlaylistBusy", "renderNamedPlaylist");
|
|
assert.match(busy, /state\.manualFinancialRestore\.entries\.size > 0/u);
|
|
|
|
const render = functionBody(app, "renderNamedPlaylist", "beginNamedPlaylistOperation");
|
|
assert.match(render, /const freshRestorePending = state\.manualFinancialRestore\.entries\.size > 0/u);
|
|
assert.match(render, /const busy = Boolean\(pending\) \|\| freshRestorePending/u);
|
|
assert.match(render, /else if \(freshRestorePending\)[\s\S]*재검증 중/u);
|
|
assert.match(render, /namedPlaylistLoadButton\.disabled = !nativeBridge \|\| locked \|\| busy/u);
|
|
|
|
for (const name of [
|
|
"requestNamedPlaylistLoad",
|
|
"requestNamedPlaylistCreate",
|
|
"requestNamedPlaylistReplace",
|
|
"requestNamedPlaylistDelete"
|
|
]) {
|
|
const body = functionBody(app, name, null);
|
|
assert.match(body, /namedPlaylistBusy\(\)/u);
|
|
}
|
|
});
|
|
|
|
test("playlist editing cannot orphan a queued manual restore and failed rows remain removable", () => {
|
|
const editable = functionBody(app, "requirePlaylistEditable", "updateClock");
|
|
assert.match(editable, /restoreRecords[\s\S]*record\.status === "error"/u);
|
|
assert.match(editable,
|
|
/state\.namedPlaylist\.pending \|\| state\.namedPlaylist\.pagePlanPending/u);
|
|
assert.match(editable, /allowFailedManualRestore && failedRestoreOnly/u);
|
|
|
|
const remove = functionBody(app, "deleteSelected", "deleteAllPlaylistEntries");
|
|
assert.match(remove, /deletingFailedRestores/u);
|
|
assert.match(remove, /requirePlaylistEditable\(deletingFailedRestores\)/u);
|
|
assert.match(remove, /requestNextManualFinancialRestore\(\)/u);
|
|
|
|
const removeAll = functionBody(app, "deleteAllPlaylistEntries", "selectPlaylistBoundary");
|
|
assert.match(removeAll, /requirePlaylistEditable\(failedRestoreOnly\)/u);
|
|
assert.match(removeAll, /clearNamedPlaylistLoadState\(\)/u);
|
|
});
|
|
|
|
test("stored GraphE entries remain unplayable until exact non-truncated DB revalidation", () => {
|
|
const normalizeStored = functionBody(app, "normalizeStoredPlaylist", "manualFinancialRestoreRecordForRequest");
|
|
assert.match(normalizeStored, /manualFinancialWorkflow\.restorePlaylistEntry\(item\)/u);
|
|
assert.match(normalizeStored, /options\.manualFinancialRestores\.push\(pendingManualFinancialEntry\)/u);
|
|
assert.match(normalizeStored,
|
|
/operatorInputBuilderKeys\.has\(String\(item\.builderKey \|\| ""\)\) \|\| item\.operator !== undefined[\s\S]*return \[\]/u);
|
|
|
|
const stockRestore = functionBody(
|
|
app,
|
|
"handleManualFinancialRestoreStockResults",
|
|
"handleManualFinancialRestoreStockError");
|
|
assert.match(stockRestore, /response\.query\s*[!=]==?\s*record\.request\.query|record\.request\.query\s*[!=]==?\s*response\.query/u);
|
|
assert.match(stockRestore, /response\.truncated/u);
|
|
assert.match(stockRestore, /response\.totalRowCount[\s\S]*record\.request\.maximumResults/u);
|
|
assert.match(stockRestore,
|
|
/const expectedMarket = [\s\S]*record\.pending\.verifiedStock\.market/u);
|
|
assert.match(stockRestore,
|
|
/const expectedCode = [\s\S]*record\.pending\.verifiedStock\.code/u);
|
|
assert.match(stockRestore,
|
|
/verifyStockForRecord\([\s\S]*expectedMarket,[\s\S]*expectedCode/u);
|
|
assert.match(stockRestore,
|
|
/record\.restoreKind === "named-financial"[\s\S]*namedMatch\.length === 1/u);
|
|
|
|
const prepareBlock = functionBody(app, "manualFinancialPrepareBlocked", "loadPlaylist");
|
|
assert.match(prepareBlock, /state\.manualFinancialRestore\.entries\.size > 0/u);
|
|
assert.match(prepareBlock, /manualFinancialWorkflow\.isPlaylistEntryPlayable\(item\)/u);
|
|
assert.match(app,
|
|
/prepareButton\.disabled = [^;]*manualFinancialBlocked/u);
|
|
const requestCommand = functionBody(app, "requestPlayoutCommand", "requestPlayoutStatus");
|
|
assert.match(requestCommand,
|
|
/if \(command === "prepare"\)[\s\S]*if \(manualFinancialPrepareBlocked\(\)\)[\s\S]*return false/u);
|
|
});
|
|
|
|
test("NXT GraphE restore searches the raw master name but verifies the suffixed display identity", () => {
|
|
const loadResults = functionBody(
|
|
app,
|
|
"handleManualFinancialRestoreLoadResults",
|
|
"handleManualFinancialRestoreLoadError");
|
|
assert.match(loadResults,
|
|
/expectedMarket[\s\S]*startsWith\("nxt-"\)[\s\S]*endsWith\(suffix\)[\s\S]*slice\(0, -suffix\.length\)/u);
|
|
assert.match(loadResults, /query: searchQuery/u);
|
|
|
|
const stockResults = functionBody(
|
|
app,
|
|
"handleManualFinancialRestoreStockResults",
|
|
"handleManualFinancialRestoreStockError");
|
|
assert.match(stockResults,
|
|
/item\.name === record\.pending\.stockName && item\.market === record\.pending\.market/u);
|
|
assert.match(stockResults, /manualFinancialWorkflow\.verifyStockForRecord/u);
|
|
});
|
|
|
|
test("native root routes all operator families and invalidates every browser correlation", () => {
|
|
assert.match(mainWindow, /TryHandleOperatorCatalogRequest\(request\.Type, request\.Payload\)/u);
|
|
assert.match(mainWindow, /TryHandleManualFinancialRequest\(request\.Type, request\.Payload\)/u);
|
|
assert.match(mainWindow, /case "request-manual-operator-data-status"/u);
|
|
assert.match(mainWindow, /case "save-manual-net-sell-data"/u);
|
|
assert.match(mainWindow, /case "save-vi-manual-list"/u);
|
|
|
|
assert.match(mainWindow, /InvalidateOperatorCatalogBrowserRequests\(\)/u);
|
|
assert.match(mainWindow, /InvalidateManualOperatorBrowserRequests\(\)/u);
|
|
assert.match(mainWindow, /InvalidateManualFinancialBrowserRequests\(\)/u);
|
|
|
|
assert.match(manualFinancialBridge, /_playoutCommandGate\.WaitAsync\(0,/u);
|
|
assert.match(manualFinancialBridge, /_databaseActivityGate\.WaitAsync\(0,/u);
|
|
assert.match(operatorCatalogBridge, /_playoutCommandGate\.WaitAsync\(0,/u);
|
|
assert.match(operatorCatalogBridge, /_databaseActivityGate\.WaitAsync\(0,/u);
|
|
assert.match(manualListsBridge, /TryEnterManualMutationGatesAsync/u);
|
|
assert.match(manualListsBridge, /_playoutCommandGate\.WaitAsync\(0\)/u);
|
|
});
|
|
|
|
test("native operator writes share one fail-closed idle gate at their dispatch boundary", () => {
|
|
const gateStart = playoutBridge.indexOf("private bool CanStartOperatorMutation(");
|
|
const gateEnd = playoutBridge.indexOf("private void ShutdownPlayoutRuntime(", gateStart);
|
|
assert.ok(gateStart >= 0 && gateEnd > gateStart);
|
|
const gate = playoutBridge.slice(gateStart, gateEnd);
|
|
assert.match(gate, /familyWriteQuarantined/u);
|
|
assert.match(gate, /_lifetimeCancellation\.IsCancellationRequested/u);
|
|
assert.match(gate, /_playoutCommandInFlight/u);
|
|
assert.match(gate, /_playoutShutdownStarted/u);
|
|
assert.match(gate, /IsBrowserCorrelationQuarantined\(\)/u);
|
|
assert.match(gate, /IsEngineAvailable: engine is not null/u);
|
|
assert.match(gate, /IsWorkflowAvailable: workflow is not null/u);
|
|
assert.match(gate, /IsCommandAvailable: status\?\.IsCommandAvailable \?\? false/u);
|
|
assert.match(gate, /IsPlayCompletionPending: status\?\.IsPlayCompletionPending \?\? true/u);
|
|
assert.match(gate, /PreparedSceneName: status\?\.PreparedSceneName/u);
|
|
assert.match(gate, /OnAirSceneName: status\?\.OnAirSceneName/u);
|
|
assert.match(gate, /PreparedCutCode: workflowState\?\.PreparedCutCode/u);
|
|
assert.match(gate, /OnAirCutCode: workflowState\?\.OnAirCutCode/u);
|
|
assert.match(gate, /IsRefreshActive: refreshStatus\.IsActive/u);
|
|
assert.match(gate, /IsRefreshTaskRunning: _legacyRefreshTask is \{ IsCompleted: false \}/u);
|
|
assert.match(gate, /OperatorMutationGate\.CanStart\(snapshot\)/u);
|
|
assert.match(operatorMutationGate, /snapshot is not null/u);
|
|
assert.match(operatorMutationGate, /snapshot\.IsEngineAvailable/u);
|
|
assert.match(operatorMutationGate, /snapshot\.IsWorkflowAvailable/u);
|
|
|
|
assert.match(manualFinancialBridge,
|
|
/CanStartOperatorMutation\(IsManualFinancialWriteQuarantined\(\)\)/u);
|
|
assert.ok((manualFinancialBridge.match(/CanStartManualFinancialWrite\(\)/gu) || []).length >= 3);
|
|
assert.match(operatorCatalogBridge,
|
|
/CanStartOperatorMutation\(IsOperatorCatalogWriteQuarantined\(\)\)/u);
|
|
assert.ok((operatorCatalogBridge.match(/CanStartOperatorCatalogWrite\(\)/gu) || []).length >= 2);
|
|
assert.match(manualListsBridge,
|
|
/CanStartOperatorMutation\(IsManualOperatorWriteQuarantined\(\)\)/u);
|
|
assert.ok((manualListsBridge.match(
|
|
/CanStartOperatorMutation\(IsManualOperatorWriteQuarantined\(\)\)/gu) || []).length >= 3);
|
|
|
|
for (const write of [
|
|
sliceBetween(
|
|
manualListsBridge,
|
|
"private async Task HandleManualNetSellWriteAsync(",
|
|
"private async Task HandleViManualListReadAsync("),
|
|
sliceBetween(
|
|
manualListsBridge,
|
|
"private async Task HandleViManualListWriteAsync(",
|
|
"private async Task<bool> TryEnterManualMutationGatesAsync(")
|
|
]) {
|
|
assert.match(write,
|
|
/TryEnterManualMutationGatesAsync\([\s\S]*Interlocked\.Exchange\(ref _manualOperatorWriteInFlight, 1\)[\s\S]*await (?:store\.)?Write/su);
|
|
}
|
|
});
|
|
|
|
test("an unknown write outcome globally quarantines GraphE, ThemeA/EList, FSell/VI and named playlists", () => {
|
|
assert.match(playoutBridge,
|
|
/private int _operatorMutationQuarantined;[\s\S]*private string\? _operatorMutationQuarantineMessage;/u);
|
|
assert.match(playoutBridge,
|
|
/private bool IsOperatorMutationQuarantined\(\) =>[\s\S]*_operatorMutationQuarantined/u);
|
|
assert.match(playoutBridge,
|
|
/private void LatchOperatorMutationQuarantine\(string message\)[\s\S]*Interlocked\.CompareExchange\(ref _operatorMutationQuarantined, 1, 0\)/u);
|
|
|
|
for (const [surface, source, familyCheck, familyLatch] of [
|
|
["GraphE", manualFinancialBridge,
|
|
"IsManualFinancialWriteQuarantined", "LatchManualFinancialWriteQuarantine"],
|
|
["ThemeA/EList", operatorCatalogBridge,
|
|
"IsOperatorCatalogWriteQuarantined", "LatchOperatorCatalogWriteQuarantine"],
|
|
["FSell/VI", manualListsBridge,
|
|
"IsManualOperatorWriteQuarantined", "QuarantineManualOperatorWrites"],
|
|
["named playlist", namedPlaylistBridge,
|
|
"IsNamedPlaylistWriteQuarantined", "LatchNamedPlaylistWriteQuarantine"]
|
|
]) {
|
|
assert.match(source, new RegExp(
|
|
`private bool ${familyCheck}\\(\\) =>[\\s\\S]{0,180}IsOperatorMutationQuarantined\\(\\)`, "u"),
|
|
`${surface} must observe the process-wide quarantine`);
|
|
assert.match(source, new RegExp(
|
|
`private void ${familyLatch}\\(string message\\)[\\s\\S]{0,260}LatchOperatorMutationQuarantine\\(message\\)`, "u"),
|
|
`${surface} must latch the process-wide quarantine`);
|
|
}
|
|
});
|
|
|
|
test("malformed operator payloads retain a family-specific fail-closed fallback", () => {
|
|
assert.match(manualFinancialBridge,
|
|
/TryHandleManualFinancialRequest\(string\? requestType, JsonElement payload\)[\s\S]*case "create-manual-financial-record"[\s\S]*return true/u);
|
|
assert.match(manualFinancialBridge,
|
|
/private static string SafeManualFinancialRequestId\(JsonElement payload\) =>[\s\S]*payload\.ValueKind == JsonValueKind\.Object/u);
|
|
assert.match(operatorCatalogBridge,
|
|
/TryHandleOperatorCatalogRequest\(string\? requestType, JsonElement payload\)[\s\S]*case "create-theme-catalog"[\s\S]*case "create-expert-catalog"[\s\S]*return true/u);
|
|
assert.match(operatorCatalogBridge,
|
|
/private static string SafeOperatorCatalogRequestId\(JsonElement payload\)[\s\S]*payload\.ValueKind == JsonValueKind\.Object/u);
|
|
|
|
for (const [parser, nextParser, readToken] of [
|
|
["TryParseAudienceRequest", "SafeManualOperatorRequestId", 'GetString(payload, "audience")'],
|
|
["TryParseManualNetSellWrite", "TryParseViWrite", 'GetString(payload, "audience")'],
|
|
["TryParseViWrite", "TryGetViExpectedVersion", "TryGetViExpectedVersion(payload"]
|
|
]) {
|
|
const body = sliceBetween(
|
|
manualListsBridge,
|
|
`private static bool ${parser}(`,
|
|
`private static ${nextParser === "SafeManualOperatorRequestId" ? "string" : "bool"} ${nextParser}(`);
|
|
assert.match(body, /requestId = SafeManualOperatorRequestId\(payload\)/u, parser);
|
|
const objectGuard = body.indexOf("payload.ValueKind");
|
|
const firstPropertyRead = body.indexOf(readToken);
|
|
assert.ok(objectGuard >= 0 && firstPropertyRead > objectGuard,
|
|
`${parser} must check object kind before reading a property`);
|
|
}
|
|
assert.ok((manualListsBridge.match(/"INVALID_REQUEST"/gu) || []).length >= 5);
|
|
|
|
const viVersion = sliceBetween(
|
|
manualListsBridge,
|
|
"private static bool TryGetViExpectedVersion(",
|
|
"private static bool TryGetManualValue(");
|
|
assert.ok(viVersion.indexOf("payload.ValueKind") <
|
|
viVersion.indexOf('payload.TryGetProperty("expectedVersion"'));
|
|
|
|
assert.match(mainWindow,
|
|
/case "request-named-playlist-list":[\s\S]*case "delete-named-playlist":[\s\S]*PostNamedPlaylistError\([\s\S]*"INVALID_REQUEST"/u);
|
|
});
|
|
|
|
test("window shutdown disposes both trusted manual stores and the one-time importer after their gate is idle", () => {
|
|
const closed = sliceBetween(mainWindow, "private void OnClosed(", "private sealed record WebRequest(");
|
|
assert.match(closed, /ShutdownManualOperatorDataRuntime\(\)/u);
|
|
|
|
const shutdown = sliceBetween(
|
|
manualListsBridge,
|
|
"private void ShutdownManualOperatorDataRuntime(",
|
|
"private async Task DisposeManualOperatorStoresWhenIdleAsync(");
|
|
assert.match(shutdown, /InvalidateManualOperatorBrowserRequests\(\)/u);
|
|
assert.match(shutdown, /Interlocked\.Exchange\(ref _manualNetSellStore, null\)/u);
|
|
assert.match(shutdown, /Interlocked\.Exchange\(ref _viManualListStore, null\)/u);
|
|
assert.match(shutdown, /Interlocked\.Exchange\(ref _legacyManualOperatorDataImporter, null\)/u);
|
|
assert.match(shutdown, /DisposeManualOperatorStoresWhenIdleAsync\(netSellStore, viStore, importer\)/u);
|
|
|
|
const dispose = sliceBetween(
|
|
manualListsBridge,
|
|
"private async Task DisposeManualOperatorStoresWhenIdleAsync(",
|
|
"private void InvalidateManualOperatorBrowserRequests(");
|
|
assert.match(dispose, /await _manualOperatorDataGate\.WaitAsync\(\)/u);
|
|
assert.match(dispose, /importer\?\.Dispose\(\)/u);
|
|
assert.match(dispose, /viStore\?\.Dispose\(\)/u);
|
|
assert.match(dispose, /netSellStore\?\.Dispose\(\)/u);
|
|
assert.match(dispose, /_manualOperatorDataGate\.Release\(\)/u);
|
|
});
|
|
|
|
test("system close requires an explicit default-cancel confirmation without an automatic playout command", () => {
|
|
assert.match(mainWindow,
|
|
/InitializeComponent\(\);\s*LogNativeOperatorStartup\(\);\s*EnsureCloseConfirmationAttached\(\);/u);
|
|
assert.match(mainWindow,
|
|
/private void OnClosed\([\s\S]*DetachCloseConfirmation\(\);[\s\S]*ShutdownPlayoutRuntime\(\)/u);
|
|
|
|
assert.match(closeConfirmationBridge,
|
|
/appWindow\.Closing \+= OnAppWindowClosing/u);
|
|
assert.match(closeConfirmationBridge,
|
|
/if \(Volatile\.Read\(ref _closeConfirmed\) != 0\)[\s\S]*args\.Cancel = true/u);
|
|
assert.match(closeConfirmationBridge,
|
|
/Interlocked\.CompareExchange\(ref _closeConfirmationPending, 1, 0\)/u);
|
|
assert.match(closeConfirmationBridge,
|
|
/DefaultButton = ContentDialogButton\.Close/u);
|
|
assert.match(closeConfirmationBridge,
|
|
/result != ContentDialogResult\.Primary/u);
|
|
assert.match(closeConfirmationBridge,
|
|
/Interlocked\.Exchange\(ref _closeConfirmed, 1\);\s*Close\(\);/u);
|
|
assert.match(closeConfirmationBridge,
|
|
/appWindow\.Closing -= OnAppWindowClosing/u);
|
|
assert.match(closeConfirmationBridge,
|
|
/종료 과정에서는 TAKE OUT을 자동 실행하지 않습니다/u);
|
|
assert.doesNotMatch(closeConfirmationBridge,
|
|
/TakeOutAsync|StopAll|StopAllAsync|playout-command/u);
|
|
});
|
|
|
|
test("operator modals isolate global playout and playlist keyboard shortcuts", () => {
|
|
const modalGate = functionBody(app, "hasOpenOperatorModal", "isolateOperatorModalShortcut");
|
|
assert.match(modalGate,
|
|
/dialog\[open\], \[role="dialog"\]\[aria-modal="true"\]/u);
|
|
assert.match(modalGate, /!element\.hidden && !element\.closest\("\[hidden\]"\)/u);
|
|
|
|
const isolation = functionBody(app, "isolateOperatorModalShortcut", null);
|
|
assert.match(isolation, /if \(!hasOpenOperatorModal\(\)\) return false/u);
|
|
for (const key of ["F2", "F3", "F8", "Escape", "Home", "End", "Delete"]) {
|
|
assert.match(isolation, new RegExp(`"${key}"`, "u"));
|
|
}
|
|
assert.match(isolation, /event\.ctrlKey && key\.toLowerCase\(\) === "k"/u);
|
|
assert.match(isolation, /showToast\("편집 창을 먼저 닫은 뒤 송출 명령을 실행하세요\."\)/u);
|
|
|
|
const keyHandler = app.slice(app.indexOf('document.addEventListener("keydown"'));
|
|
const gate = keyHandler.indexOf("if (isolateOperatorModalShortcut(event)) return;");
|
|
const playout = keyHandler.indexOf('if (["F2", "F3", "F8", "Escape"].includes(event.key))');
|
|
const playlistDelete = keyHandler.indexOf('if (event.key === "Delete")');
|
|
assert.ok(gate >= 0 && playout > gate && playlistDelete > gate);
|
|
});
|
|
|
|
test("generic native bridge errors are bounded and visible without inventing correlation", () => {
|
|
const bridgeError = functionBody(app, "handleBridgeError", "handleNativeMessage");
|
|
assert.match(bridgeError, /rawMessage\.length <= 512/u);
|
|
assert.match(bridgeError, /Native Bridge가 올바르지 않은 요청을 거부했습니다/u);
|
|
assert.match(bridgeError, /addLog\(`Native Bridge 요청 오류 · \$\{message\}`\)/u);
|
|
assert.match(bridgeError, /showToast\(message\)/u);
|
|
assert.doesNotMatch(bridgeError,
|
|
/pendingCommand\s*=\s*null|clearPlayoutError|requestPlayoutCommand|retry/u);
|
|
|
|
const nativeSwitch = functionBody(app, "handleNativeMessage", null);
|
|
assert.match(nativeSwitch,
|
|
/case "bridge-error":\s*handleBridgeError\(message\.payload\);\s*break;/u);
|
|
});
|
|
|
|
test("GraphE async UI boundaries retain the dispatcher context before posting WebView replies", () => {
|
|
assert.doesNotMatch(manualFinancialBridge,
|
|
/operationBody\(requestToken\)\.ConfigureAwait\(false\)/u);
|
|
assert.doesNotMatch(manualFinancialBridge,
|
|
/preflight\(requestToken\)\.ConfigureAwait\(false\)/u);
|
|
assert.doesNotMatch(manualFinancialBridge,
|
|
/operationBody\(service,\s*requestToken\)\.ConfigureAwait\(false\)/u);
|
|
});
|