From 176d9ff6a33512a25c8e8e38e245bbf84504c9c1 Mon Sep 17 00:00:00 2001
From: LiZhenhai-MBP14 <5935568+jackhai9@users.noreply.github.com>
Date: Wed, 16 Sep 2026 14:45:10 +0800
Subject: [PATCH 1/2] test: establish behavioral test policy and coverage gates
---
.github/workflows/binance-orderbook-ui.yml | 4 +-
.../workflows/binance-strategy27-events.yml | 5 +-
.github/workflows/userscript-tests.yml | 78 ++
AGENTS.md | 4 +
docs/binance-orderbook-trade-development.md | 10 +
docs/binance-orderbook-trade-ui-automation.md | 21 +
docs/test-coverage.md | 128 ++
docs/test-policy.md | 208 +++
docs/test-selection.md | 164 +++
docs/userscript-validation.md | 13 +
.../fixtures/binance-futures.js | 81 +-
.../helpers/scenario-clock.js | 12 +
.../helpers/userscript-page.js | 44 +-
.../scenarios/cancel-current-symbol.js | 38 +-
.../specs/cancel-covering-matrix.pw.js | 5 +-
.../specs/cancel-current-symbol.pw.js | 126 +-
.../specs/close-ladder-recovery.pw.js | 15 +-
.../specs/control-flows.pw.js | 241 +++-
.../specs/coverage-merge.pw.js | 96 ++
.../specs/depth-profile-labels.pw.js | 32 +-
.../specs/live-performance-probe.pw.js | 63 +-
.../specs/panel-visual-contract.pw.js | 20 +-
.../specs/precision-controls.pw.js | 35 +-
.../specs/strategy29-coexistence.pw.js | 13 +-
.../specs/strategy29-panel-drag.pw.js | 19 +-
.../specs/unicode-symbols.pw.js | 17 +-
.../specs/userscript-performance.pw.js | 16 +-
e2e/binance-orderbook/test.js | 14 +
eslint.config.js | 37 +
package-lock.json | 1224 ++++++++++++++++-
package.json | 11 +-
scripts/binance-orderbook-trade.user.js | 13 +-
scripts/test-coverage/branch-policy.json | 12 +
scripts/test-coverage/browser-reporter.mjs | 26 +
scripts/test-coverage/capture-contract.mjs | 29 +
scripts/test-coverage/collect-browser.mjs | 30 +
scripts/test-coverage/collect-node.mjs | 39 +
scripts/test-coverage/config.mjs | 44 +
scripts/test-coverage/gates.mjs | 37 +
scripts/test-coverage/merge-proof.mjs | 170 +++
scripts/test-coverage/report.mjs | 79 ++
scripts/test-coverage/run.mjs | 98 ++
scripts/test-coverage/source-maps.mjs | 136 ++
scripts/test-coverage/split-entries.mjs | 129 ++
scripts/test-policy/ast.js | 160 +++
scripts/test-policy/eslint-plugin.js | 309 +++++
scripts/test-policy/migration-inventory.js | 176 +++
scripts/test-selection/graph.mjs | 283 ++++
scripts/test-selection/node-runner.mjs | 30 +
scripts/test-selection/run.mjs | 139 ++
.../core/continuous-ladder.js | 2 +-
src/binance-orderbook-trade/core/quantity.js | 10 +-
src/binance-orderbook-trade/index.user.js | 2 +-
test/unit/binance-fixture-contract.test.js | 198 +++
.../binance-orderbook-trade/cancel.test.js | 842 +++++++-----
.../chart-save-coalescer.test.js | 942 ++++++++++---
.../close-action.test.js | 195 +--
.../close-ladder-recovery.test.js | 204 ++-
.../continuous-ladder.test.js | 432 ++++--
.../order-feedback.test.js | 711 +++++++---
.../binance-orderbook-trade/quantity.test.js | 143 +-
.../binance-orderbook-trade/smoke.test.js | 6 -
.../source-regressions.test.js | 7 -
test/unit/coverage-capture.test.js | 81 ++
test/unit/coverage-gates.test.js | 97 ++
test/unit/coverage-report.test.js | 88 ++
test/unit/coverage-split.test.js | 146 ++
test/unit/test-policy.test.js | 414 ++++++
test/unit/test-selection.test.js | 584 ++++++++
69 files changed, 8661 insertions(+), 1176 deletions(-)
create mode 100644 .github/workflows/userscript-tests.yml
create mode 100644 docs/test-coverage.md
create mode 100644 docs/test-policy.md
create mode 100644 docs/test-selection.md
create mode 100644 e2e/binance-orderbook/helpers/scenario-clock.js
create mode 100644 e2e/binance-orderbook/specs/coverage-merge.pw.js
create mode 100644 eslint.config.js
create mode 100644 scripts/test-coverage/branch-policy.json
create mode 100644 scripts/test-coverage/browser-reporter.mjs
create mode 100644 scripts/test-coverage/capture-contract.mjs
create mode 100644 scripts/test-coverage/collect-browser.mjs
create mode 100644 scripts/test-coverage/collect-node.mjs
create mode 100644 scripts/test-coverage/config.mjs
create mode 100644 scripts/test-coverage/gates.mjs
create mode 100644 scripts/test-coverage/merge-proof.mjs
create mode 100644 scripts/test-coverage/report.mjs
create mode 100644 scripts/test-coverage/run.mjs
create mode 100644 scripts/test-coverage/source-maps.mjs
create mode 100644 scripts/test-coverage/split-entries.mjs
create mode 100644 scripts/test-policy/ast.js
create mode 100644 scripts/test-policy/eslint-plugin.js
create mode 100644 scripts/test-policy/migration-inventory.js
create mode 100644 scripts/test-selection/graph.mjs
create mode 100644 scripts/test-selection/node-runner.mjs
create mode 100644 scripts/test-selection/run.mjs
create mode 100644 test/unit/binance-fixture-contract.test.js
delete mode 100644 test/unit/binance-orderbook-trade/smoke.test.js
create mode 100644 test/unit/coverage-capture.test.js
create mode 100644 test/unit/coverage-gates.test.js
create mode 100644 test/unit/coverage-report.test.js
create mode 100644 test/unit/coverage-split.test.js
create mode 100644 test/unit/test-policy.test.js
create mode 100644 test/unit/test-selection.test.js
diff --git a/.github/workflows/binance-orderbook-ui.yml b/.github/workflows/binance-orderbook-ui.yml
index 1b61026..593d1a0 100644
--- a/.github/workflows/binance-orderbook-ui.yml
+++ b/.github/workflows/binance-orderbook-ui.yml
@@ -6,6 +6,7 @@ on:
- ".github/workflows/binance-orderbook-ui.yml"
- "package.json"
- "package-lock.json"
+ - ".nvmrc"
- "playwright.config.js"
- "src/binance-orderbook-trade/**"
- "src/binance-strategy29-bollinger/**"
@@ -29,6 +30,7 @@ on:
- ".github/workflows/binance-orderbook-ui.yml"
- "package.json"
- "package-lock.json"
+ - ".nvmrc"
- "playwright.config.js"
- "src/binance-orderbook-trade/**"
- "src/binance-strategy29-bollinger/**"
@@ -57,7 +59,7 @@ jobs:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
- node-version: 22
+ node-version-file: .nvmrc
cache: npm
- run: npm ci
- run: npx playwright install --with-deps chromium
diff --git a/.github/workflows/binance-strategy27-events.yml b/.github/workflows/binance-strategy27-events.yml
index 5cb75f7..2f05a63 100644
--- a/.github/workflows/binance-strategy27-events.yml
+++ b/.github/workflows/binance-strategy27-events.yml
@@ -6,6 +6,7 @@ on:
- ".github/workflows/binance-strategy27-events.yml"
- "package.json"
- "package-lock.json"
+ - ".nvmrc"
- "scripts/build-userscript.mjs"
- "scripts/userscript-release-contract.mjs"
- "src/binance-strategy27-events/**"
@@ -23,6 +24,7 @@ on:
- ".github/workflows/binance-strategy27-events.yml"
- "package.json"
- "package-lock.json"
+ - ".nvmrc"
- "scripts/build-userscript.mjs"
- "scripts/userscript-release-contract.mjs"
- "src/binance-strategy27-events/**"
@@ -45,7 +47,7 @@ jobs:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
- node-version: 22
+ node-version-file: .nvmrc
cache: npm
- run: npm ci
- run: npm run test:binance-strategy27-events
@@ -53,4 +55,3 @@ jobs:
- run: git diff --exit-code -- scripts/binance-strategy27-events.user.js
- run: npm run check:binance-userscripts
- run: node scripts/userscript-release-contract.mjs scripts/binance-strategy27-events.user.js
-
diff --git a/.github/workflows/userscript-tests.yml b/.github/workflows/userscript-tests.yml
new file mode 100644
index 0000000..4460633
--- /dev/null
+++ b/.github/workflows/userscript-tests.yml
@@ -0,0 +1,78 @@
+name: Userscript Tests
+
+on:
+ pull_request:
+ push:
+ branches: [main]
+ schedule:
+ - cron: "0 20 * * 0"
+ workflow_dispatch:
+
+permissions:
+ contents: read
+
+concurrency:
+ group: userscript-tests-${{ github.event.pull_request.number || github.ref }}
+ cancel-in-progress: true
+
+jobs:
+ tests:
+ runs-on: ubuntu-latest
+ timeout-minutes: 30
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ fetch-depth: 0
+ persist-credentials: false
+ - uses: actions/setup-node@v4
+ with:
+ node-version-file: .nvmrc
+ cache: npm
+ - run: npm ci
+ - run: npm run lint:tests
+ - run: npm run build:userscripts
+ - run: git diff --exit-code -- 'scripts/*.user.js'
+ - run: npm run check:binance-userscripts
+ - run: npm run check:m3u8-downloader
+ - name: Select affected tests
+ id: selection
+ env:
+ TEST_BASE_SHA: ${{ github.event.pull_request.base.sha || github.event.before }}
+ TEST_FULL: ${{ github.event_name == 'schedule' || github.event_name == 'workflow_dispatch' }}
+ run: |
+ mkdir -p test-results
+ if [ "$TEST_FULL" = "true" ]; then
+ node scripts/test-selection/run.mjs --full --list > test-results/selection.json
+ else
+ node scripts/test-selection/run.mjs --base "$TEST_BASE_SHA" --list > test-results/selection.json
+ fi
+ node --input-type=module <<'JS'
+ import { appendFileSync, readFileSync } from 'node:fs';
+ const plan = JSON.parse(readFileSync('test-results/selection.json', 'utf8'));
+ appendFileSync(process.env.GITHUB_OUTPUT, 'browser=' + (plan.browserTests.length > 0) + '\n');
+ process.stdout.write(JSON.stringify(plan, null, 2) + '\n');
+ JS
+ - name: Install browser for selected scenarios
+ if: steps.selection.outputs.browser == 'true'
+ run: npx playwright install --with-deps chromium
+ - name: Run affected tests
+ if: github.event_name != 'schedule' && github.event_name != 'workflow_dispatch'
+ env:
+ TEST_BASE_SHA: ${{ github.event.pull_request.base.sha || github.event.before }}
+ run: npm run test:affected -- --base "$TEST_BASE_SHA"
+ - name: Run complete source coverage
+ if: github.event_name == 'schedule' || github.event_name == 'workflow_dispatch'
+ run: npm run test:coverage
+ - name: Upload test selection and reports
+ if: always()
+ uses: actions/upload-artifact@v4
+ with:
+ name: userscript-test-evidence
+ path: |
+ test-results/selection.json
+ playwright-report/
+ test-results/coverage/latest.json
+ test-results/coverage/run-*/report/
+ test-results/coverage/run-*/node-results.txt
+ if-no-files-found: ignore
+ retention-days: 14
diff --git a/AGENTS.md b/AGENTS.md
index 2217071..b80d800 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -39,6 +39,7 @@
| Strategy 29 observer or cross-script chart coordination | docs/binance-strategy29-bollinger-development.md |
| Brooks/m3u8 indexing, export state, timing, or captions | docs/brooks-media-sync-workflow.md |
| Trading-data, CoinMarketCap-data, auto-refresh, or cross-script validation | docs/userscript-validation.md |
+| Behavioral tests, test lint, affected selection, or source coverage | docs/test-policy.md |
| Read-only review | skills/userscript-review/SKILL.md |
| Release or publish | skills/userscript-release/SKILL.md |
| Codex/browser/proxy/helper/connection timeout | global timeout rule; if available, ~/.dotfiles/knowledge/shared/CODEX_TOOL_TIMEOUT_TRIAGE.md |
@@ -78,6 +79,9 @@
## Validation
+- Changed tests must pass `npm run lint:tests`. The behavioral test policy and
+ explicit migration inventory are owned by `docs/test-policy.md`; affected
+ selection and coverage commands do not replace required builds or live checks.
- Run the affected tests, build, syntax/check commands, and git diff --check for
behavior changes. The release skill owns stage-specific validation and reuse
of passing local checks for unchanged inputs.
diff --git a/docs/binance-orderbook-trade-development.md b/docs/binance-orderbook-trade-development.md
index add000d..8ce2e7b 100644
--- a/docs/binance-orderbook-trade-development.md
+++ b/docs/binance-orderbook-trade-development.md
@@ -56,6 +56,11 @@ Include affected shared-contract and integration checks when the change crosses
script boundaries. Full-suite release validation and reuse of passing local
results are defined in `skills/userscript-release/SKILL.md`.
+Test work also follows [Behavioral Test Policy](test-policy.md). Prefer executable
+entry-to-outcome scenarios over source-text assertions for runtime behavior;
+retain metadata, generated-artifact, and module-boundary contracts. Test changes
+must pass `npm run lint:tests` in addition to the affected behavior checks.
+
## Layout
```text
@@ -283,6 +288,11 @@ Continuous ladder trading is available only for close actions through `Option/Al
Continuous-session feedback stays in the shared ladder status row and uses `连续阶梯平多` / `连续阶梯平空` as the stable action name. The action, phase, and counters are separated with ` · ` instead of concatenating `连续` after the ordinary ladder label. `2/3 轮` means two rounds completed out of three started, `本轮 1/3 笔` reports the active or latest partial plan, and `累计 7 笔` reports all confirmed submissions across the session. Confirmed cancellations are appended only when greater than zero. The active round must combine its live progress with the completed-round aggregate; ordinary single-round status text must never overwrite the continuous-session identity. Round outcomes must expose a detached progress snapshot so a terminal continuous summary cannot be overwritten by the latest single-round message.
+A session waiting for readiness, stopping, or failing before its first recorded
+round has `lastRound: null`. Its status shows zero rounds and zero confirmed
+submissions, with no current-plan segment. Formatting this valid initial state
+must not fail or invent a round.
+
The active continuous-close control keeps a compact direction-specific stop action (`停止平多` / `停止平空`) on one line throughout both execution and inter-round waiting. Before the native submit control is ready, the status places `等待按钮恢复` immediately after the continuous action name. Only after the fixed cooldown actually begins may it show `1s 后继续` in that same priority position; this is a static duration label, not a countdown. `停止中`, `已停止`, `失败`, and `已中止` use the same phase slot. The button must not temporarily revert to a ladder-start action between rounds.
When a continuous close receives the observed Binance private-page response `code=90802025`, `success=false`, and the max-open-orders message, classify it as a confirmed no-submit capacity rejection. Load the complete lazy current-orders list before ranking rows; the first 50 rendered rows are not a complete candidate set. Release up to 50 current-symbol, same-close-direction Basic limit orders farthest from the current trade price, preserving the nearest orders that are most likely to complete the close. Resume the same unsubmitted ladder level so already confirmed levels are not duplicated. Permit this recovery once per round; a second confirmed capacity rejection ends the current round and lets continuous mode resume after its recovery delay. Do not use Cancel All, and do not touch open-direction, opposite-direction, conditional, or protection orders. If a selected row disappears because it fills while recovery is running, treat that slot as already released but count a cancellation only after the script confirms its own row-cancel action.
diff --git a/docs/binance-orderbook-trade-ui-automation.md b/docs/binance-orderbook-trade-ui-automation.md
index 1625d5e..621df9b 100644
--- a/docs/binance-orderbook-trade-ui-automation.md
+++ b/docs/binance-orderbook-trade-ui-automation.md
@@ -34,6 +34,27 @@ L0 and L1 remain fast PR gates. L2 owns the full scenario matrix. L3 and L4 are
smaller integration and release gates because extension state, network timing, and
market state are not deterministic enough for the full matrix.
+Scenario naming, Given/When/Then structure, assertions, and permitted test
+boundaries follow [Behavioral Test Policy](test-policy.md). L2 still executes the
+generated install artifact. Its reviewed fake is tested separately in
+`test/unit/binance-fixture-contract.test.js`: wrong symbol filtering or the wrong
+Basic/conditional tab must produce the corresponding wrong cancellation scope,
+so the fake cannot silently repair an unsafe caller. Native confirmation and
+delayed clearing retain the initiating scope snapshot.
+
+Use `helpers/scenario-clock.js` for business deadlines, cooldowns, and negative
+proofs such as no new submission after Stop. A pending request stays pending
+until `releaseSubmitResponse()` explicitly delivers success or rejection. Keep
+performance budgets on real `performance` time; advancing a virtual clock is
+not a latency or throughput measurement. The ordinary single-round unknown
+submission scenario must not be generalized to continuous mode, whose existing
+`submit_unconfirmed` policy deliberately permits a later recovery round.
+
+`npm run test:coverage` additionally collects V8 execution and maps it to the
+complete production source set. The collector's own browser proof uses virtual
+code and remains separate from production coverage. See [Source Coverage](test-coverage.md)
+for report completeness and shared-source merge checks.
+
## Scenario Model
Scenarios are data, not copied test procedures. Each scenario declares these axes:
diff --git a/docs/test-coverage.md b/docs/test-coverage.md
new file mode 100644
index 0000000..ec02204
--- /dev/null
+++ b/docs/test-coverage.md
@@ -0,0 +1,128 @@
+# Production Source Coverage
+
+Coverage measures all JavaScript under `src/` and the two hand-maintained install
+scripts, `scripts/auto_refresh.user.js` and
+`scripts/coinmarketcap-valuation-helper.user.js`. Generated install artifacts are
+mapped back to their original sources, so they do not create another denominator.
+Unexecuted source files remain in the report with zero execution credit. Test
+files, fixtures, build tooling, and historical installer snapshots are not
+production source. The executable scope lives in
+[`scripts/test-coverage/config.mjs`](../scripts/test-coverage/config.mjs).
+
+Use `.nvmrc` and install Chromium before collecting the browser layer:
+
+```sh
+nvm use
+npm ci
+npx playwright install chromium
+npm run test:coverage
+```
+
+`npm run test:coverage:node` collects only Node unit and JSDOM execution, while
+retaining the same complete-source denominator. Its result is labeled Node-only;
+it cannot satisfy the merged-coverage gate. Neither command starts a development
+server or operates a logged-in browser.
+
+## Accurate Mapping and Completion
+
+The coverage compiler reads complete source entries, including userscript
+metadata, to preserve original line positions. It requires generated executable
+bytes to match the public install artifacts and checks every embedded original
+against the current source file. A stale artifact fails collection instead of
+producing a report for different code.
+
+The selected Node files are passed to `node:test` through `run({ files })`, not
+the CLI's glob expansion. Coverage imports are installed in those actual test
+processes. Selected filenames remain literal, including glob metacharacters,
+spaces, and newlines.
+
+Node's inspector records the actual executed script source as well as precise
+V8 ranges. Complete anonymous VM sources can be identified by exact content.
+Partial functions extracted from a source file and quoted copies of installer
+text receive no credit for executing that source file. Browser collection also
+recognizes complete original modules loaded through Blob URLs.
+
+One browser script can contain several installers. The collector validates exact
+installer segments against JavaScript statement boundaries and keeps their V8
+execution ranges associated with the original bytes. Shared originals appear
+once in the final report. An isolated Node-and-Chromium proof checks known branch
+counts so repeated bundled copies cannot hide a branch executed by another copy.
+
+Every selected Node test process must finish its capture. Every production
+browser scenario must pass and finish its capture, with IDs matched against the
+current Playwright run. Missing, stale, skipped, or retried browser evidence
+invalidates completeness. The one explicit collector self-test file uses virtual
+code; it must pass but does not contribute production coverage. Source-map and
+capture tests validate these boundaries independently.
+
+## Target and Staged Gate
+
+The final repository target is **90% branch coverage across the complete scope**.
+The rollout also uses an explicit **66.5% aggregate floor** and requires each
+migrated critical module to reach 90%. The floor rounds the initial 66.58%
+measurement down to one decimal place. The checked-in threshold policy names
+those files; it does not exclude other production sources from the aggregate.
+
+The staged gate and final target are separate facts. A run may pass the staged
+gate while still reporting `meetsBranchTarget: false`. It must not be described as
+reaching the repository target. Threshold decisions use exact covered/total
+counts, not rounded display percentages. New failures, recovery paths, and
+boundary conditions should close the remaining gap; do not shrink the source
+scope, remove a guard, or invent invalid business states to improve the metric.
+
+`npm run test:coverage -- --require-target` also requires the final aggregate 90%
+target. `npm run test:coverage -- --report-only` collects diagnostic evidence
+without applying thresholds; CI uses the default gated command. The aggregate
+floor and exact critical-source list are stored in
+[`branch-policy.json`](../scripts/test-coverage/branch-policy.json).
+
+The policy applies to merged Node and browser results. The complete pipeline runs
+weekly and through manual workflow dispatch in `.github/workflows/userscript-tests.yml`.
+PRs and main pushes run test lint, generated-artifact checks, and the
+[affected test selection](test-selection.md). The existing script-specific
+workflows retain their independent checks.
+
+## Reports and Interpretation
+
+The complete baseline on 2026-09-16 used Node 24.16.0, 97 Node test files
+(1,326 passing tests), and 92 passing Chromium scenarios. The browser total
+contains 87 production scenarios and five collector proofs. All required
+captures completed. The merged denominator contains 82 distinct production
+source files and **6,765 / 10,160 covered branches (66.58%)**.
+The six unmapped VM entries are executions of the three historical installers in
+`test/fixtures/strategy29-migration/`, each loaded twice by the settings migration
+tests. They remain visible in the report and receive no current-source credit.
+
+| Migrated critical source | Covered / total branches | Coverage |
+| --- | ---: | ---: |
+| `core/cancel-orders.js` | 74 / 74 | 100% |
+| `core/close-action.js` | 39 / 42 | 92.86% |
+| `core/close-ladder-recovery.js` | 39 / 39 | 100% |
+| `core/continuous-ladder.js` | 108 / 119 | 90.76% |
+| `core/order-feedback.js` | 194 / 204 | 95.10% |
+| `core/quantity.js` | 26 / 27 | 96.30% |
+| `core/chart-save-coalescer.js` | 247 / 273 | 90.48% |
+
+These paths are under `src/binance-orderbook-trade/`. The baseline passes the
+staged policy and fails the final aggregate 90% target. This is a dated
+measurement, not a promise about later revisions; current reports record source
+hashes so their scope can be verified.
+
+Each collection creates `test-results/coverage/run-*/` with the raw captures,
+Node test output, and a `report/` directory. `test-results/coverage/latest.json`
+points to the last completed report; check its run path and source identity rather
+than assuming an older report covers current edits.
+
+The HTML entry is `report/index.html`. `report/coverage-summary.json` records:
+
+- Node version, executed layers, source list, and original source identities;
+- exact branch, statement, function, line, and byte metrics;
+- the final target and whether it was met;
+- capture completeness counts and any executed entries that could not be mapped.
+
+An unmapped historical installer or extracted snippet is visible as unmapped
+evidence and is not substituted for current-source execution. Tests passing,
+capture completion, meeting a staged threshold, and meeting the final 90% target
+are distinct outcomes. Browser fixture coverage is L2 evidence; Tampermonkey
+installation and current Binance behavior still require their own authorized
+L3/L4 checks.
diff --git a/docs/test-policy.md b/docs/test-policy.md
new file mode 100644
index 0000000..ff33e8b
--- /dev/null
+++ b/docs/test-policy.md
@@ -0,0 +1,208 @@
+# Behavioral Test Policy
+
+The repository keeps Node's `node:test` runner, JSDOM, and Playwright. Tests should
+describe an observable outcome, execute the real behavior being checked, and fail
+when that outcome changes. A new runner or a large mocking framework is not
+required for this policy.
+
+Use the Node version pinned by `.nvmrc`. The relevant commands are:
+
+| Command | Evidence |
+| --- | --- |
+| `npm run lint:tests` | Test policy checks across `test/` and `e2e/`; zero warnings are allowed. |
+| `npm run test:test-policy` | The ESLint rules accept valid programs and reject concrete invalid programs. |
+| `npm test` | Existing Node unit and JSDOM integration tests. |
+| `npm run test:ui` | Offline Playwright scenarios using the generated userscripts and controlled host fixtures. |
+| `npm run test:affected` | The repository's affected-test selector; consult its selection output before interpreting the result. |
+| `npm run test:coverage:node` | Production-source coverage from the Node layer. |
+| `npm run test:coverage` | Complete Node and browser source coverage, with the staged aggregate and critical-module gates. |
+
+The specialized validation paths, builds, and any required live checks remain in
+[Userscript Validation](userscript-validation.md) and the linked script manuals.
+Browser fixture tests establish the controlled host contract. They do not prove
+the current live Binance DOM or grant permission for financial actions.
+
+## Behavior Names and Stages
+
+New test files and all `e2e/**/specs/**/*.pw.js` scenarios use a title beginning with
+`user `. Describe the observable behavior in the rest of the title. A
+parameterized title such as `` `user sees ${quantity} accepted orders` `` keeps a
+static `user ` prefix.
+
+Every test has concrete, ordered Given, When, and Then stages. Prefer awaited
+`test.step` calls in Playwright when their scope fits the scenario:
+
+```js
+test('user sees confirmation after the order response is accepted', async ({ page }) => {
+ await test.step('Given the order panel has a valid quantity', async () => {
+ await openOrderPanel(page, { quantity: 2 });
+ });
+ await test.step('When the user submits the order', async () => {
+ await page.getByRole('button', { name: 'Submit' }).click();
+ });
+ await test.step('Then the accepted quantity is shown in the status', async () => {
+ await expect(page.getByRole('status')).toHaveText('Submitted 2');
+ });
+});
+```
+
+Node tests, and browser scenarios that share local state across stages, may use
+comments directly around executable statements:
+
+```js
+test('user keeps existing orders when cancellation is declined', async () => {
+ // Given the user has current-symbol and unrelated orders
+ const exchange = createExchangeFixture({ orders: initialOrders });
+
+ // When the user declines the native cancellation confirmation
+ await exchange.requestCancellation({ confirmation: 'decline' });
+
+ // Then every original order remains present
+ assert.deepEqual(exchange.orders(), initialOrders);
+});
+```
+
+Each stage needs its own executable setup, action, or assertion and a description
+of at least two words. Bare keywords, generic placeholders, three adjacent empty
+comments, labels inside strings, and labels inside unused functions do not
+satisfy the rule. Put stage boundaries outside conditional branches and loops;
+the behavior must have phases for every invocation. Setup and cleanup may use
+`try`/`finally` blocks.
+
+A completed Then stage may be followed by another When/Then pair. A new
+Given/When/Then sequence is also allowed after a completed Then. Assertions about
+preconditions may appear during Given; assertions are not mechanically restricted
+to Then. `test.step` calls must be awaited or returned to preserve execution
+order. Inline callbacks keep the stage contract locally inspectable.
+
+## Boundaries, Clocks, and Assertions
+
+Prefer real pure functions and real DOM adapters. When a test needs an external
+boundary, give its fake explicit state and operations and test that fake's
+contract independently. The browser host fixture has contract checks in
+`test/unit/binance-fixture-contract.test.js`; changes to its supported DOM,
+request/response, event, or cancellation behavior require corresponding checks.
+Do not replace a business method just to force the branch under test.
+
+New uses of `mock.method` and `mock.fn` are rejected, including ordinary imported,
+destructured, computed-property, and bound aliases. `mock.timers` remains the
+supported Node clock. For browser business timing, install and advance
+Playwright's page clock. Negative timing assertions should check the state before
+the deadline and after the explicit clock advance. A response gate can preserve
+a pending request until the scenario deliberately releases it.
+
+Do not wait a fixed number of real milliseconds before an assertion. The rule
+rejects `waitForTimeout`, Promise-resolving `setTimeout` calls, promise-timer
+imports, and calls named `sleep` or `delay`. Use a response gate, observable DOM
+state, event completion, or virtual-clock advance. Timeouts that bound an
+operation, reject a deadline, or configure the runner are valid. Host-fixture
+timers that emit modeled upstream events are also valid; scenarios should control
+them through the page clock when checking timing.
+
+Real performance measurements must observe real browser execution. The one
+approved performance task boundary is listed separately below. A virtual-clock
+result must not be reported as a measured long-task duration or throughput.
+
+The policy rejects focused, skipped, pending, or deferred cases (`only`, `skip`,
+`todo`, and `fixme`), including Node test options and imperative context skips.
+Unrelated data fields named `only` remain valid. No existing skipped-test
+exception is recorded.
+
+Empty callbacks and tests that only compare constants or a value with itself
+are rejected. Useful metadata, generated-artifact, and architecture assertions
+such as `assert.match(source, /@downloadURL/)` remain valid. Runtime behavior
+should be checked through results and effects instead of merely searching for
+its implementation text.
+
+## Staged Migration and Exact Allowances
+
+The first strict Node behavior group covers these orderbook suites:
+
+- `cancel`, `close-action`, and `close-ladder-recovery`;
+- `continuous-ladder`, `order-feedback`, and `quantity`;
+- `chart-save-coalescer`.
+
+The new policy, fixture-contract, coverage-report, and test-selection suites are
+also strict. Every new `*.test.js` file is strict by default. All browser spec
+files are strict.
+
+The remaining existing Node suites are individually listed, with migration
+reasons, in
+[`scripts/test-policy/migration-inventory.js`](../scripts/test-policy/migration-inventory.js).
+Only their BDD organization is deferred. Focus/skip, empty-test, new mock, and new
+fixed-wait rules still apply. This is explicit migration debt, not proof that the
+legacy suites already satisfy the behavior policy. Add new scenarios in strict
+files or migrate the whole existing file and remove its inventory entry.
+
+The two `source-regressions.test.js` files contain both useful source contracts
+and behavioral checks awaiting migration. Neither file is classified wholesale
+as an architectural test. Preserve the useful contracts while migrating the
+behavioral assertions to executable scenarios.
+
+The remaining method replacements have exact file/target/count allowances:
+
+| File | Retained calls | Remaining work |
+| --- | --- | --- |
+| `test/dom/binance-trading-data-footer.test.js` | `Date.now`: 1 | Move the extracted footer's elapsed-time harness to a deterministic clock. |
+| `test/dom/binance-strategy27-events/compound-candidate-controller.test.js` | `crypto.subtle.digest`: 1 | Move the lifecycle hash pause into a contract-tested crypto boundary. |
+| `test/dom/binance-strategy27-events/strategy27-entrypoint.test.js` | `Date.now`, page `setInterval`/`clearInterval`, `querySelectorAll`, and `prompt`: 1 each | Replace the clock overrides and move query/prompt instrumentation into explicit fixture contracts. |
+
+The remaining fixed waits are likewise bounded:
+
+| File | Retained calls | Remaining work |
+| --- | --- | --- |
+| `test/unit/m3u8-downloader-course-export.test.js` | `setTimeout(20)`: 19; `650`: 1; `1100`: 1 | Introduce export/download completion signals and a virtual runtime clock. |
+| `test/dom/binance-strategy29-bollinger/runtime.test.js` | `f.view.setTimeout(0)`: 5 | Expose remote-request and DOM-render completion signals. |
+| `test/unit/binance-orderbook-trade/trade-form.test.js` | `dom.window.setTimeout(0)`: 3 | Await the observed request or mutation completion. |
+| `test/unit/binance-orderbook-trade/cancel-all-dialog.test.js` | `dom.window.setTimeout(0)`: 1 | Observe delivery of unrelated mutations for the negative case. |
+| `test/dom/binance-strategy29-bollinger/tradingview-bearish-alerts.test.js` | `setTimeout(0)`: 1 | Preserve the actual render-task-yield contract through a controlled scheduling boundary. |
+
+Adding another occurrence or a different target fails lint. Removing an old
+occurrence also fails until its allowance is reduced or removed. This makes the
+inventory shrink as work is migrated. The complete reasons and counts are stored
+in the executable inventory rather than a directory-wide ESLint disable.
+
+One separate host contract allows exactly one `window.setTimeout(0)` inside
+`finishAfterPerformanceTail` in
+`e2e/binance-orderbook/helpers/live-performance-probe.js`. PerformanceObserver
+entries arrive after the observed host task, so this boundary collects the real
+performance tail before tearing down observers. It is not a business wait or a
+measurement made with a virtual clock. The rule tests verify that a second call
+inside that method or a new wait elsewhere in the same file is rejected.
+
+Inline `eslint-disable` directives cannot turn off the policy. Historical
+installation artifacts under `test/fixtures/` are excluded from lint because
+they are test input source snapshots, not executable test definitions.
+
+## Coverage Target and Evidence Limits
+
+The repository target is **90% branch coverage**. The coverage collector reports
+the complete production-source denominator, including unexecuted files, and
+maps generated artifacts back to their source. The denominator and target live
+in `scripts/test-coverage/config.mjs`.
+
+The default complete run enforces a **66.5% aggregate floor** and **90% for each
+of the seven migrated critical modules**. The initial complete baseline is
+66.58% across 82 production files; the floor rounds that measured value down to
+one decimal place. This preserves an explicit starting gate while the remaining
+behavioral coverage is migrated. The executable threshold and file list live in
+[`branch-policy.json`](../scripts/test-coverage/branch-policy.json).
+
+A successful staged run does not prove that the repository's final 90% target
+was met. Inspect `gate`, `meetsBranchTarget`, `summary.branches.pct`, and the
+recorded layers in `coverage-summary.json`. Use
+`npm run test:coverage -- --require-target` to require the final aggregate target;
+`--report-only` collects diagnostic evidence without enforcing thresholds.
+Node-only results must remain labeled Node-only and cannot satisfy the merged
+gate. See [Source Coverage](test-coverage.md) for the measured baseline and
+complete-source contract.
+
+The enforced test policy, the explicit legacy migration inventory, and the
+coverage target are different facts. Report each separately. Do not shrink the
+coverage denominator or mark a legacy suite migrated merely to improve a number.
+
+Static lint catches the documented syntax and ordinary aliases; it does not
+prove that assertions express the correct domain contract or that arbitrary
+dynamically generated JavaScript executes the intended phases. Review scenarios
+and run them. A useful behavior test must fail when the behavior it protects is
+removed or changed.
diff --git a/docs/test-selection.md b/docs/test-selection.md
new file mode 100644
index 0000000..208f262
--- /dev/null
+++ b/docs/test-selection.md
@@ -0,0 +1,164 @@
+# Test selection
+
+The affected-test runner selects complete Node test files and Playwright specs from
+the current repository inventory. It combines verified dependency edges with every
+consumer whose runtime dependencies cannot be proved. Unknown readers remain in
+the plan even when another test is already known to consume a changed file.
+
+## Commands and scope
+
+| Scope | Command | Purpose |
+| --- | --- | --- |
+| Test policy | `npm run lint:tests` | Enforce the executable test-policy rules independently of test selection. |
+| Affected behaviors | `npm run test:affected` | Run affected files and all uncertain consumers after local changes. |
+| Complete behaviors | `npm run test:affected -- --full` | Run every discovered Node test and Playwright spec. |
+| Complete source coverage | `npm run test:coverage` | Collect the full Node and Chromium coverage run and enforce its coverage policy. |
+
+Use the Node version in `.nvmrc`, for example with `nvm use`, before invoking these
+commands. The selector checks the exact running Node version and uses
+`process.execPath` for child processes. Lint is a separate command; selection never
+silently runs or substitutes for test lint. L0/L1/L2 retain their runtime meanings
+from the UI automation manual: Node core, JSDOM, and Playwright respectively.
+See [test policy](test-policy.md) and
+[coverage](test-coverage.md) for their respective contracts.
+
+## Commands and change discovery
+
+Run the commands from the repository root:
+
+```sh
+npm run test:affected
+npm run test:affected -- --base origin/main
+npm run test:affected -- --full
+node scripts/test-selection/run.mjs --list
+npm run --silent test:affected -- --base origin/main --list
+```
+
+Without `--base`, the selector compares the working tree with `HEAD`. It resolves
+the base to an available commit, collects `git diff --name-only --no-renames -z`
+against that commit, and includes untracked paths from Git. The inventory also
+includes untracked tests and excludes tracked files that no longer exist.
+NUL-delimited Git output preserves spaces and newlines in filenames. A rename
+retains both the old deletion and the new addition in the changed-path set.
+
+`--base REF` compares against the supplied commit rather than assuming a CI
+event's previous SHA exists locally. Missing arguments, all-zero bases,
+unavailable commits, an unborn `HEAD`, and unknown or repeated options fail
+explicitly. `--full` still requires valid repository state and a resolvable base.
+Neither an invalid base nor failed discovery becomes an empty successful plan.
+
+`--list` prints only the JSON plan and does not run tests. Use npm's `--silent`
+option when parsing npm output, since npm otherwise adds its own banner. Store
+captured plans under the ignored `test-results/` directory so the output does not
+become a new unmapped input to the next selection.
+
+The JSON interface is versioned:
+
+```json
+{
+ "schemaVersion": 1,
+ "mode": "affected",
+ "reasons": ["Selected complete test files through dependency edges and all unresolved consumers"],
+ "changedFiles": ["src/example.js"],
+ "nodeTests": ["test/unit/example.test.js"],
+ "browserTests": []
+}
+```
+
+`mode` is `none`, `affected`, or `full`. Path arrays contain sorted,
+repository-relative filenames. `reasons` explains selection and any uncertainty;
+consumers should use `mode` and the path arrays rather than parse diagnostic text.
+
+An actual run prints a plan summary, runs the selected Node files first, and then
+runs the selected Playwright specs. A failed runner stops the sequence. Commands
+use argument arrays without a shell. Node uses the programmatic `run({ files })`
+interface because its CLI interprets positional filenames as glob patterns.
+Playwright's filename filters are escaped and suffix-anchored because its CLI
+interprets those filters as regular expressions. Selection is by whole file,
+never by individual test title.
+
+## Dependency evidence
+
+The test roots are:
+
+- `test/unit/**/*.test.js`
+- `test/dom/**/*.test.js`
+- `e2e/**/specs/**/*.pw.js`, including specs nested below the specs directory
+
+The Playwright configuration must expose a static `testDir` under
+`e2e/.../specs` and the recursive `testMatch: '**/*.pw.js'` contract. The parser
+supports the exported object directly or its `defineConfig(...)` wrapper.
+
+Acorn parses local static imports, exports, literal dynamic imports, static
+`new URL(..., import.meta.url)` expressions, and literal paths that match inventory
+files. URL references follow URL encoding rules, including encoded spaces and
+newlines. Literal URL strings, templates without substitutions, and literal string
+concatenation can be resolved without runtime value analysis.
+
+Generated userscripts inherit the `entry` declared for their `output` in the
+exported `TARGETS` object in `scripts/build-userscript.mjs`. Dependencies then
+continue through the source entry and its shared modules. The selector does not
+execute the builder or hand-maintain a second artifact-to-source mapping.
+Unsupported, unsafe, duplicate, or unavailable build mappings prevent a partial
+plan from claiming that the artifact graph is complete.
+
+Snapshot ownership follows the verified Playwright template:
+
+```js
+snapshotPathTemplate: '{testDir}/{testFilePath}-snapshots/{arg}{ext}'
+```
+
+For example, `specs/nested/panel.pw.js-snapshots/panel.json` belongs to
+`specs/nested/panel.pw.js`. This edge does not require a literal snapshot filename
+inside the spec. Other snapshot layouts are not assumed to have equivalent
+ownership rules.
+
+## Uncertainty and full runs
+
+A module that imports `fs`, `fs/promises`, `child_process`, or `module`, with or
+without the `node:` prefix, always has uncertain runtime dependencies. This also
+applies to literal dynamic imports of those modules and CommonJS loaders. Static
+paths in such a module still add useful edges, but never remove its uncertainty.
+This intentionally retains readers accessed through aliases, destructuring,
+shadowed parameters, `createRequire`, subprocesses, and directory scans. A module
+that only writes files can therefore select more tests than strictly necessary.
+
+Nonliteral dynamic imports, runtime URL expressions, unsupported executable
+dependencies, missing referenced files, and opaque URL module imports also retain
+their complete test consumers. Finite-looking arrays are not treated as immutable
+path domains: mutation, aliasing, and function calls can change the values used by
+a template. If a template-derived resource has no independently verified edge,
+changing it still requires a full run.
+
+Uncertainty records carry explicit `file`, `reason`, and `scope` fields internally.
+Consumer-scoped records propagate through reverse dependencies to every owning
+test root. Every nonempty change set, including documentation changes, selects
+those complete files. Independently verified affected consumers are then added.
+Tests outside both sets can be omitted.
+
+A full run is selected when:
+
+- `--full` is requested.
+- Package manifests or lockfiles, `.nvmrc`, workflows, Playwright configuration,
+ ESLint configuration, the userscript builder, or `scripts/test-*` infrastructure
+ changes.
+- A changed path was deleted, is unavailable, or has no verified consumer and is
+ not an eligible documentation file. Unmapped JSON, HTML, images, snapshots, and
+ source files all remain runtime changes.
+- Build mapping, Playwright discovery, or snapshot ownership cannot be verified
+ globally, or an uncertain dependency cannot be assigned to a test owner.
+
+A failed file read or Git operation is an explicit command failure rather than a
+successful empty result. Protected configuration and credential paths are never
+read by graph construction; their presence as changed filenames can still require
+a full run.
+
+`none` is allowed for a valid graph with no changes, or for documentation without
+known or uncertain runtime consumers. Eligible documentation is Markdown under
+`docs/` and the documented root Markdown names such as `README.md` and `AGENTS.md`.
+A Markdown extension alone is not enough to skip a runtime reader.
+
+The selector does not generate userscripts, install them, activate live browser
+sessions, or authorize financial actions. Its browser execution is the project's
+configured Playwright test suite; manual or live validation remains a separate
+project requirement.
diff --git a/docs/userscript-validation.md b/docs/userscript-validation.md
index e7a974f..afd30fa 100644
--- a/docs/userscript-validation.md
+++ b/docs/userscript-validation.md
@@ -11,6 +11,12 @@ are owned by `skills/userscript-release/SKILL.md`.
The eight-script performance audit, operation-count baselines, and reproduction
commands are recorded in `docs/userscript-performance-review.md`.
+The behavioral test rules, reviewed fake contracts, virtual-time boundaries,
+and explicit migration inventory are owned by [Behavioral Test Policy](test-policy.md).
+Use [Affected Test Selection](test-selection.md) for dependency-based local and CI
+selection, and [Source Coverage](test-coverage.md) for the complete-source coverage
+scope, threshold policy, and report interpretation.
+
## Script Matrix
| Script | Editable source | Artifact | Focused checks | Detailed guide |
@@ -34,6 +40,13 @@ The default suite runs all `test/unit/**/*.test.js` and `test/dom/**/*.test.js`
files. Scripts under `test/manual/` are explicit manual probes and previews;
they are not automatically executed by the test runner.
+Test changes also run `npm run lint:tests`. `npm run test:affected -- --list`
+explains the selected Node and browser files before execution. The scheduled
+`Userscript Tests` workflow runs the complete Node and browser coverage pipeline;
+ordinary PR and main-push runs select tests using an explicit Git base. Existing
+script-specific workflows retain their independent checks. All three workflows
+read the Node version from `.nvmrc`.
+
## Shared Contracts
- A migrated script is edited under `src/`; its generated artifact is rebuilt
diff --git a/e2e/binance-orderbook/fixtures/binance-futures.js b/e2e/binance-orderbook/fixtures/binance-futures.js
index 2ef2336..d076163 100644
--- a/e2e/binance-orderbook/fixtures/binance-futures.js
+++ b/e2e/binance-orderbook/fixtures/binance-futures.js
@@ -132,7 +132,10 @@ export function renderBinanceFuturesFixture(scenario) {
...detail,
});
const currentOrders = () => state.orders.filter((item) => item.symbol === scenario.currentSymbol);
- const visibleOrders = () => state.hideOtherSymbols ? currentOrders() : state.orders;
+ const visibleOrders = () => state.orders.filter((item) => (
+ item.kind === state.openOrdersSubTab
+ && (!state.hideOtherSymbols || item.symbol === scenario.currentSymbol)
+ ));
const selected = (value, expected) => String(value === expected);
const scheduleCommit = (callback) => setTimeout(callback, scenario.host.mutationDelayMs);
let orderSubmitSequence = 0;
@@ -211,23 +214,29 @@ export function renderBinanceFuturesFixture(scenario) {
price: orderEntry.querySelector('input[id^="limitPrice-"]')?.value || '',
quantity: orderEntry.querySelector('input[id^="unitAmount-"]')?.value || '',
});
- window.fetch('/bapi/futures/v1/private/future/order/place-order', {
- method: 'POST',
- headers: { 'content-type': 'application/json' },
- body: JSON.stringify({ submitSequence }),
- }).then(() => record('order-submit-api-success', { submitSequence }));
- const showFeedback = () => {
+ const showFeedback = (outcome) => {
const feedback = document.createElement('div');
feedback.setAttribute('role', 'alert');
- feedback.textContent = '订单已提交成功';
+ feedback.textContent = outcome === 'success' ? '订单已提交成功' : '订单提交失败';
document.body.append(feedback);
- record('order-submit-feedback', { action: button.textContent.trim(), submitSequence });
+ record('order-submit-feedback', { action: button.textContent.trim(), submitSequence, outcome });
};
- if (scenario.host.submitFeedbackDelayMs > 0) {
- setTimeout(showFeedback, scenario.host.submitFeedbackDelayMs);
- } else {
- showFeedback();
- }
+ window.fetch('/bapi/futures/v1/private/future/order/place-order', {
+ method: 'POST',
+ headers: { 'content-type': 'application/json' },
+ body: JSON.stringify({ submitSequence }),
+ }).then(async (response) => {
+ const payload = await response.json();
+ const outcome = response.ok && payload.success === true ? 'success'
+ : payload.success === false ? 'rejected' : 'unknown';
+ record('order-submit-api-' + outcome, { submitSequence, code: payload.code });
+ if (outcome === 'unknown') return;
+ if (scenario.host.submitFeedbackDelayMs > 0) {
+ setTimeout(() => showFeedback(outcome), scenario.host.submitFeedbackDelayMs);
+ } else {
+ showFeedback(outcome);
+ }
+ });
});
});
orderEntry.querySelectorAll('input').forEach((input) => {
@@ -351,6 +360,8 @@ export function renderBinanceFuturesFixture(scenario) {
function renderAccountWidget() {
const positionCount = state.positions.length;
const orderCount = state.orders.length;
+ const basicCount = state.orders.filter((order) => order.kind === 'basic').length;
+ const conditionalCount = state.orders.filter((order) => order.kind === 'conditional').length;
accountWidget.innerHTML =
'
`],
- actionButtons: [],
+ actionButtons: activeStopButtons,
};
}
if (tradeMode === 'OPEN') {
diff --git a/src/m3u8-downloader/index.user.js b/src/m3u8-downloader/index.user.js
index 3a85a21..a535c5b 100644
--- a/src/m3u8-downloader/index.user.js
+++ b/src/m3u8-downloader/index.user.js
@@ -3,7 +3,7 @@
// @namespace https://github.com/jackhai9/userscripts
// @icon data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%2064%2064%22%3E%3Crect%20width%3D%2264%22%20height%3D%2264%22%20rx%3D%2214%22%20fill%3D%22%23f0b90b%22%2F%3E%3Ctext%20x%3D%2232%22%20y%3D%2249%22%20text-anchor%3D%22middle%22%20font-family%3D%22Arial%2C%20sans-serif%22%20font-size%3D%2242%22%20font-weight%3D%22800%22%20fill%3D%22%23111827%22%3EJ%3C%2Ftext%3E%3C%2Fsvg%3E
// @icon64 data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%2064%2064%22%3E%3Crect%20width%3D%2264%22%20height%3D%2264%22%20rx%3D%2214%22%20fill%3D%22%23f0b90b%22%2F%3E%3Ctext%20x%3D%2232%22%20y%3D%2249%22%20text-anchor%3D%22middle%22%20font-family%3D%22Arial%2C%20sans-serif%22%20font-size%3D%2242%22%20font-weight%3D%22800%22%20fill%3D%22%23111827%22%3EJ%3C%2Ftext%3E%3C%2Fsvg%3E
-// @version 0.10.38
+// @version 0.10.40
// @description m3u8 下载增强脚本，仅在白名单视频站启用，避免误伤交易页等重前端应用
// @author jackhai9
// @include https://18jav.tv/*
@@ -21,6 +21,7 @@
import { M3U8_MESSAGE_TYPE } from './constants.js'
import {
+ buildCaptionUrlFromM3u8,
buildExternalDownloaderUrl,
getParentMessageTargetOrigin,
getYtDlpOutputName,
@@ -350,7 +351,8 @@ import { createBrooksMediaExporter } from './brooks-exporter.js'
console.log(`Saving as: ${filename}`);
// 使用 XMLHttpRequest 替代 fetch
- return new Promise((resolve, reject) => {
+ // Await so asynchronous XHR failures reach this caption job's error boundary.
+ return await new Promise((resolve, reject) => {
let xhr = new originXHR();// 使用原始的 XMLHttpRequest
xhr.open('GET', url, true);
xhr.responseType = 'text';
diff --git a/test/dom/binance-data-panels-entrypoint.test.js b/test/dom/binance-data-panels-entrypoint.test.js
new file mode 100644
index 0000000..d3b0f37
--- /dev/null
+++ b/test/dom/binance-data-panels-entrypoint.test.js
@@ -0,0 +1,280 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+ createDataPanelHost, tradingDataset, completeTradingBatch, cmcDetail, completeCmcData,
+} from '../helpers/data-media-migration-host.js';
+
+async function activateTrading(host, dataset = tradingDataset(Date.now()), options) {
+ const time = await host.network.waitForRequest(request => !request.settled && request.url.pathname.endsWith('/time'));
+ time.respond({ serverTime: Date.now() });
+ await completeTradingBatch(host, dataset, options);
+ await host.rendered(panel => panel?.querySelector('[data-role="updated-at"]')?.textContent.startsWith('更新于'));
+}
+
+for (const scenario of [
+ { name: 'long', values: {}, oi: '2.00M ▲', composite: '偏多 7:0' },
+ { name: 'short', values: { oi: 2_000, previousOi: 4_000, ratio: 0.5, basis: -0.01, funding: 0.0002 }, oi: '2K ▼', composite: '偏空 0:7' },
+ { name: 'neutral', values: { oi: 50, previousOi: 50, ratio: 1, basis: 0, funding: 0, supply: 0 }, oi: '50.00', composite: '中性 0:0' },
+ { name: 'billion', values: { oi: 2_000_000_000 }, oi: '2.00B ▲', composite: '偏多 7:0' },
+]) {
+ test(`user sees ${scenario.name} indicators and the corresponding fresh directional votes`, { timeout: 5_000 }, async t => {
+ // Given a futures page with complete data for one directional scenario
+ const host = createDataPanelHost(t, 'trading');
+ const dataset = tradingDataset(Date.now(), scenario.values);
+
+ // When the complete installed script receives all seven endpoint responses
+ await host.start();
+ await activateTrading(host, dataset);
+
+ // Then the visible quantities, votes, and endpoint parameters match that data
+ assert.match(host.element('rows').textContent, new RegExp(scenario.oi.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
+ assert.match(host.element('composite').textContent, new RegExp(scenario.composite));
+ assert.equal(host.element('symbol').textContent, 'BTCUSDT');
+ assert.equal(host.element('rows').children.length, 8);
+ const basisRequest = host.network.requests.find(request => request.url.pathname.endsWith('/basis'));
+ assert.equal(basisRequest.url.searchParams.get('pair'), 'BTCUSDT');
+ assert.equal(basisRequest.url.searchParams.get('contractType'), 'PERPETUAL');
+ assert.equal(basisRequest.url.searchParams.get('period'), '5m');
+ });
+}
+
+test('user sees missing endpoint data explicitly and receives no retry for client errors', { timeout: 5_000 }, async t => {
+ // Given all endpoints return a deterministic 400 error for the current symbol
+ const host = createDataPanelHost(t, 'trading');
+ const dataset = tradingDataset(Date.now());
+ const statuses = Object.fromEntries(Object.keys(dataset).map(key => [key, 400]));
+
+ // When the first complete fetch fails at each endpoint
+ await host.start();
+ await activateTrading(host, dataset, { status: statuses });
+
+ // Then missing rows remain visible and cannot contribute directional votes
+ assert.equal([...host.element('rows').children].every(row => row.children[1].textContent === '--'), true);
+ assert.match(host.element('composite').textContent, /中性 0:0/);
+ assert.equal(host.network.requests.length, 8);
+ assert.equal(host.errors.length, 7);
+});
+
+test('user sees cached rows without their directional votes after a failed refresh', { timeout: 5_000 }, async t => {
+ // Given a completed bullish fetch with data available in the current-symbol cache
+ const host = createDataPanelHost(t, 'trading');
+ await host.start();
+ await activateTrading(host);
+ host.setHidden(true);
+
+ // When returning to the page encounters failures for every endpoint
+ host.setHidden(false);
+ const dataset = tradingDataset(Date.now());
+ await activateTrading(host, dataset, { status: Object.fromEntries(Object.keys(dataset).map(key => [key, 400])) });
+ await host.rendered(() => host.element('composite').textContent.includes('中性 0:0'));
+
+ // Then cached values are retained with hollow markers and no fresh votes
+ assert.match(host.element('rows').textContent, /2\.00M ▲/);
+ assert.equal([...host.element('rows').children].every(row => row.lastElementChild.style.background === 'transparent'), true);
+ assert.match(host.element('composite').textContent, /中性 0:0/);
+});
+
+test('user receives one retry for transient endpoint errors and then sees fresh data', { timeout: 5_000 }, async t => {
+ // Given a trading panel whose first endpoint request has a server failure
+ const host = createDataPanelHost(t, 'trading');
+ await host.start();
+ const time = await host.network.waitForRequest(request => request.url.pathname.endsWith('/time'));
+ time.respond({ serverTime: Date.now() });
+ const dataset = tradingDataset(Date.now());
+
+ // When the initial request fails and its single recovery request succeeds
+ await completeTradingBatch(host, dataset, { status: { openInterestHist: 503 } });
+ const retry = await host.network.waitForRequest(request => !request.settled && request.url.pathname.endsWith('/openInterestHist'));
+ retry.respond(dataset.openInterestHist);
+ await host.rendered(panel => panel?.querySelector('[data-role="updated-at"]')?.textContent.startsWith('更新于'));
+
+ // Then the rendered value is fresh and exactly two calls targeted that endpoint
+ assert.match(host.element('rows').textContent, /2\.00M ▲/);
+ assert.equal(host.network.requests.filter(request => request.url.pathname.endsWith('/openInterestHist')).length, 2);
+ assert.match(host.element('composite').textContent, /偏多 7:0/);
+});
+
+test('user sees the current period fetched only after the server boundary delay', { timeout: 5_000 }, async t => {
+ // Given the page opens exactly on a five-minute boundary with the previous period
+ const host = createDataPanelHost(t, 'trading');
+ await host.start();
+ await activateTrading(host, tradingDataset(Date.now() - 300_000));
+ const previousCount = host.network.requests.length;
+
+ // When virtual time approaches and then reaches the five-second publication delay
+ host.clock.tick(4_999);
+ assert.equal(host.network.requests.length, previousCount);
+ host.clock.tick(1);
+ await completeTradingBatch(host, tradingDataset(Date.now(), { ratio: 0.5 }));
+ await host.rendered(() => host.element('composite').textContent.includes('偏空 3:4'));
+
+ // Then one new batch updates the votes and highlights the changed ratios
+ assert.equal(host.network.requests.length, previousCount + 7);
+ assert.match(host.element('composite').textContent, /偏空 3:4/);
+ assert.equal(host.element('rows').querySelectorAll('.jh-td-flash').length, 4);
+});
+
+for (const kind of ['trading', 'cmc']) {
+ test(`user activates the ${kind} panel only on a trading route and retains their collapse choice`, { timeout: 5_000 }, async t => {
+ // Given an idle wallet route with an existing saved collapsed preference
+ const prefix = kind === 'trading' ? 'jh_binance_trading_data' : 'jh_binance_cmc_data';
+ const host = createDataPanelHost(t, kind, { path: '/zh-CN/futures', storage: { [`${prefix}_collapsed`]: '1', [`${prefix}_pos`]: '{invalid' } });
+ await host.start();
+ assert.equal(host.panel(), null);
+ assert.equal(host.network.requests.length, 0);
+
+ // When navigation enters a trading route and the upstream data arrives
+ host.navigate('/zh-CN/futures/BTCUSDT');
+ if (kind === 'trading') await activateTrading(host);
+ else await completeCmcData(host);
+ assert.equal(host.element('body').style.display, 'none');
+ host.element('collapse').click();
+
+ // Then expanding is persisted and leaving the trading route removes the panel
+ assert.equal(host.element('body').style.display, 'block');
+ assert.equal(host.window.localStorage.getItem(`${prefix}_collapsed`), '0');
+ host.element('collapse').click();
+ assert.equal(host.window.localStorage.getItem(`${prefix}_collapsed`), '1');
+ host.navigate('/zh-CN/my/wallet/futures/overview');
+ assert.equal(host.panel(), null);
+ const count = host.network.requests.length;
+ host.clock.tick(60_000);
+ assert.equal(host.network.requests.length, count);
+ });
+
+ test(`user closes the ${kind} panel without visibility or route events restarting it`, { timeout: 5_000 }, async t => {
+ // Given a running panel with one completed data refresh
+ const host = createDataPanelHost(t, kind);
+ await host.start();
+ if (kind === 'trading') await activateTrading(host);
+ else await completeCmcData(host);
+
+ // When the user closes it, hides the document, and navigates while returning
+ host.element('close').click();
+ const count = host.network.requests.length;
+ host.setHidden(true);
+ host.navigate('/zh-CN/futures/ETHUSDT');
+ host.setHidden(false);
+ host.clock.tick(3_600_000);
+
+ // Then it remains closed and none of the business timers request more data
+ assert.equal(host.panel().style.display, 'none');
+ assert.equal(host.network.requests.length, count);
+ });
+
+ test(`user drags the ${kind} panel within the viewport and stops dragging after route removal`, { timeout: 5_000 }, async t => {
+ // Given a visible panel with a valid persisted position
+ const prefix = kind === 'trading' ? 'jh_binance_trading_data' : 'jh_binance_cmc_data';
+ const host = createDataPanelHost(t, kind, { storage: { [`${prefix}_pos`]: '{"left":40,"top":80}' } });
+ await host.start();
+ if (kind === 'trading') await activateTrading(host);
+ else await completeCmcData(host);
+ const panel = host.panel();
+ const mouse = (target, type, x, y) => target.dispatchEvent(new host.window.MouseEvent(type, { bubbles: true, clientX: x, clientY: y }));
+
+ // When dragging updates the position and navigation removes the panel
+ mouse(host.element('header'), 'mousedown', 10, 10);
+ mouse(host.document, 'mousemove', 100, 120);
+ mouse(host.document, 'mousemove', 130, 150);
+ host.clock.tick(16);
+ mouse(host.document, 'mouseup', 130, 150);
+ host.window.dispatchEvent(new host.window.Event('beforeunload'));
+ host.window.dispatchEvent(new host.window.Event('resize'));
+ const beforeRemoval = panel.style.cssText;
+ host.navigate('/zh-CN/futures');
+ mouse(host.document, 'mousemove', 500, 600);
+ mouse(host.document, 'mouseup', 500, 600);
+
+ // Then the retained detached element no longer responds to drag events
+ assert.equal(host.panel(), null);
+ assert.equal(panel.style.cssText, beforeRemoval);
+ assert.deepEqual(Object.keys(JSON.parse(host.window.localStorage.getItem(`${prefix}_pos`))).sort(), ['left', 'top']);
+ });
+}
+
+test('user sees CMC API provenance and all valuation rows after a deterministic asset mapping', { timeout: 5_000 }, async t => {
+ // Given a Bitcoin futures route with a unique active CMC mapping
+ const host = createDataPanelHost(t, 'cmc');
+
+ // When the complete installed script receives map, detail, and holder responses
+ await host.start();
+ await completeCmcData(host);
+
+ // Then values, ranking, holder count, and source appear in the real panel DOM
+ assert.equal(host.element('symbol').textContent, 'BTC #1');
+ assert.equal(host.element('rows').children.length, 12);
+ assert.match(host.element('rows').textContent, /流通市值\$1\.2万亿-1\.00%/);
+ assert.match(host.element('rows').textContent, /持有者1万/);
+ assert.match(host.element('rows').textContent, /Profile score85%/);
+ assert.equal(host.element('footer').querySelector('a').href, 'https://coinmarketcap.com/zh/currencies/bitcoin/');
+ assert.match(host.element('footer').textContent, /CMC data-api/);
+});
+
+for (const scenario of [
+ { name: 'missing', rows: [], error: 'CMC symbol not found: BTC' },
+ { name: 'ambiguous', rows: [{ id: 1, symbol: 'BTC', slug: 'bitcoin', is_active: 1 }, { id: 2, symbol: 'BTC', slug: 'other', is_active: 1 }], error: 'CMC symbol ambiguous: BTC' },
+ { name: 'inactive', rows: [{ id: 1, symbol: 'BTC', slug: 'bitcoin', is_active: 0 }], error: 'CMC symbol not found: BTC' },
+]) {
+ test(`user sees an explicit error for a ${scenario.name} CMC asset mapping`, { timeout: 5_000 }, async t => {
+ // Given the current symbol has no single valid mapping response
+ const host = createDataPanelHost(t, 'cmc');
+
+ // When the map endpoint returns the specified candidate set
+ await host.start();
+ const request = await host.network.waitForRequest(request => request.url.pathname.endsWith('/map'));
+ request.respond({ data: scenario.rows });
+ await host.rendered(() => host.element('rows').textContent.includes(scenario.error));
+
+ // Then the panel reports that exact reason without choosing another asset
+ assert.equal(host.element('rows').textContent, `读取失败${scenario.error}`);
+ assert.equal(host.network.requests.length, 1);
+ });
+}
+
+for (const outcome of ['http', 'network', 'timeout', 'json', 'statistics']) {
+ test(`user sees page-snapshot provenance when the CMC API has a ${outcome} failure`, { timeout: 5_000 }, async t => {
+ // Given the RAVE override resolves directly to its documented asset
+ const host = createDataPanelHost(t, 'cmc', { path: '/futures/RAVEUSDT' });
+ const detail = cmcDetail({ id: 38967, symbol: 'RAVE', showTreasuriesFlag: true, treasuryHoldings: 1200 });
+
+ // When the API fails and the page snapshot supplies valid detail statistics
+ await host.start();
+ const api = await host.network.waitForRequest(request => request.url.pathname.endsWith('/detail'));
+ if (outcome === 'http') api.respond({}, 503);
+ else if (outcome === 'network') api.fail('error');
+ else if (outcome === 'timeout') api.fail('timeout');
+ else if (outcome === 'json') api.respond('{invalid');
+ else api.respond({ data: {} });
+ const page = await host.network.waitForRequest(request => request.url.hostname === 'coinmarketcap.com');
+ page.respond(``);
+ await host.rendered(() => host.element('footer').textContent.includes('CMC 页面快照'));
+
+ // Then the source remains visibly a page snapshot and the override bypasses mapping
+ assert.equal(host.element('footer').querySelector('a').href, 'https://coinmarketcap.com/zh/currencies/ravedao/');
+ assert.match(host.element('rows').textContent, /金库资产1200 RAVE/);
+ assert.equal(host.network.requests.length, 2);
+ });
+}
+
+test('user can refresh CMC data from the cached asset mapping without losing their current rows', { timeout: 5_000 }, async t => {
+ // Given one successful refresh with a cached symbol mapping
+ const host = createDataPanelHost(t, 'cmc');
+ await host.start();
+ await completeCmcData(host);
+ const previousRows = host.element('rows').textContent;
+
+ // When a scheduled refresh starts and receives updated market statistics
+ host.clock.tick(30_000);
+ assert.equal(host.element('rows').textContent, previousRows);
+ const detail = cmcDetail({ profileCompletionScore: 95, holders: { holderCount: 50 } });
+ detail.statistics.price = -123;
+ detail.statistics.rank = 'unknown';
+ await completeCmcData(host, detail, { map: false, holder: { showFlag: false } });
+ await host.rendered(() => host.element('rows').textContent.includes('-$123'));
+
+ // Then the new value appears and no second map request was made
+ assert.match(host.element('rows').textContent, /价格-\$123/);
+ assert.equal(host.element('symbol').textContent, 'BTC');
+ assert.match(host.element('rows').textContent, /Profile score95%/);
+ assert.equal(host.network.requests.filter(request => request.url.pathname.endsWith('/map')).length, 1);
+});
diff --git a/test/dom/binance-data-panels-responses.test.js b/test/dom/binance-data-panels-responses.test.js
new file mode 100644
index 0000000..727575f
--- /dev/null
+++ b/test/dom/binance-data-panels-responses.test.js
@@ -0,0 +1,360 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+ activateTradingData, afterDataMediaResponseTurn, completeCmcData, completeTradingBatch,
+ createDataPanelHost, cmcDetail, tradingDataset,
+} from '../helpers/data-media-migration-host.js';
+
+for (const scenario of [
+ { name: 'an empty body', body: '', error: 'CMC symbol not found: BTC' },
+ { name: 'a null payload', body: null, error: 'CMC symbol not found: BTC' },
+ { name: 'a non-array map', body: { data: {} }, error: 'CMC symbol not found: BTC' },
+ { name: 'only incomplete and inactive rows', body: { data: [null, { is_active: 1 }, { is_active: 0, symbol: 'BTC' }] }, error: 'CMC symbol not found: BTC' },
+ { name: 'a matching asset without an ID', body: { data: [{ symbol: 'BTC', slug: 'bitcoin', is_active: 1 }] }, error: '无法识别当前合约' },
+ { name: 'a matching asset without a slug', body: { data: [{ id: 1, symbol: 'BTC', is_active: 1 }] }, error: '无法识别当前合约' },
+]) {
+ test(`user sees an explicit asset error when CMC mapping returns ${scenario.name}`, { timeout: 5_000 }, async t => {
+ // Given the current contract requires one complete active asset mapping
+ const host = createDataPanelHost(t, 'cmc');
+ await host.start();
+ const mapping = await host.network.waitForRequest(request => request.url.pathname.endsWith('/map'));
+
+ // When the upstream mapping cannot identify a usable current asset
+ mapping.respond(scenario.body);
+ await host.rendered(() => host.element('rows').textContent.includes(scenario.error));
+
+ // Then the precise failure is visible and no guessed detail or page request is issued
+ assert.equal(host.element('rows').textContent, `读取失败${scenario.error}`);
+ assert.equal(host.network.requests.length, 1);
+ assert.equal(host.element('symbol').textContent, 'BTCUSDT');
+ });
+}
+
+test('user resolves the one complete active CMC asset among incomplete unrelated rows', { timeout: 5_000 }, async t => {
+ // Given the mapping endpoint returns null, inactive, and symbol-less rows beside Bitcoin
+ const host = createDataPanelHost(t, 'cmc');
+ await host.start();
+ const mapping = await host.network.waitForRequest(request => request.url.pathname.endsWith('/map'));
+
+ // When the one active complete mapping and its detail endpoints succeed
+ mapping.respond({ data: [null, { is_active: 1 }, { id: 9, symbol: 'BTC', slug: 'inactive', is_active: 0 }, { id: 1, symbol: ' btc ', slug: ' bitcoin ', is_active: 1 }] });
+ await completeCmcData(host, cmcDetail(), { map: false });
+
+ // Then the normalized Bitcoin mapping controls the public detail request and source link
+ assert.equal(host.network.requests[1].url.searchParams.get('id'), '1');
+ assert.equal(host.element('symbol').textContent, 'BTC #1');
+ assert.equal(host.element('footer').querySelector('a').href, 'https://coinmarketcap.com/zh/currencies/bitcoin/');
+ assert.equal(host.network.requests.length, 3);
+});
+
+test('user keeps valid CMC valuation data when its detail cannot identify a holder endpoint', { timeout: 5_000 }, async t => {
+ // Given Bitcoin is mapped correctly but the detail response omits its holder lookup ID
+ const host = createDataPanelHost(t, 'cmc');
+ await host.start();
+ host.network.requests[0].respond({ data: [{ id: 1, symbol: 'BTC', slug: 'bitcoin', is_active: 1 }] });
+ const request = await host.network.waitForRequest(request => request.url.pathname.endsWith('/detail'));
+ const detail = cmcDetail({ holders: { total: 17 } });
+ delete detail.id;
+
+ // When the valid valuation statistics render without a supplemental holder request
+ request.respond({ data: detail });
+ await host.rendered(() => host.element('footer').textContent.includes('CMC data-api'));
+
+ // Then the existing count and valuation rows remain usable without an invalid-ID request
+ assert.match(host.element('rows').textContent, /价格\$6万/);
+ assert.match(host.element('rows').textContent, /持有者17/);
+ assert.equal(host.network.requests.length, 2);
+ assert.equal(host.network.requests.some(request => request.url.pathname.endsWith('/show_holders')), false);
+});
+
+test('user keeps the new CMC symbol when the superseded mapping fails late', { timeout: 5_000 }, async t => {
+ // Given Bitcoin mapping is pending while the user switches to Ethereum
+ const host = createDataPanelHost(t, 'cmc');
+ await host.start();
+ const oldMapping = host.network.requests[0];
+ host.navigate('/zh-CN/futures/ETHUSDT');
+ await completeCmcData(host, cmcDetail({ id: 2, symbol: 'ETH' }), { symbol: 'ETH', slug: 'ethereum' });
+ const rows = host.element('rows').innerHTML;
+ const footer = host.element('footer').innerHTML;
+
+ // When the old Bitcoin request reports a transport failure after Ethereum has rendered
+ oldMapping.fail('error');
+ await afterDataMediaResponseTurn();
+
+ // Then the stale rejection cannot replace current rows, identity, or provenance
+ assert.equal(host.element('rows').innerHTML, rows);
+ assert.equal(host.element('footer').innerHTML, footer);
+ assert.equal(host.element('symbol').textContent, 'ETH #1');
+ assert.equal(host.network.requests.length, 4);
+});
+
+for (const scenario of [
+ { name: 'HTTP rejection', respond: request => request.respond('', 403), error: 'CMC HTTP 403' },
+ { name: 'network failure', respond: request => request.fail('error'), error: 'CMC request failed' },
+ { name: 'timeout', respond: request => request.fail('timeout'), error: 'CMC request timeout' },
+ { name: 'empty page', respond: request => request.respond(''), error: 'CMC page missing __NEXT_DATA__' },
+ { name: 'absent statistics', respond: request => request.respond(''), error: 'CMC page missing detail statistics' },
+]) {
+ test(`user sees the exact CMC page-snapshot failure after a ${scenario.name}`, { timeout: 5_000 }, async t => {
+ // Given the API is unavailable for the documented RAVE asset override
+ const host = createDataPanelHost(t, 'cmc', { path: '/futures/RAVEUSDT' });
+ await host.start();
+ const api = await host.network.waitForRequest(request => request.url.pathname.endsWith('/detail'));
+ api.respond({}, 503);
+ const page = await host.network.waitForRequest(request => request.url.hostname === 'coinmarketcap.com');
+
+ // When the fallback page fails in the specified observable way
+ scenario.respond(page);
+ await host.rendered(() => host.element('rows').textContent.includes(scenario.error));
+
+ // Then the original page failure reason remains visible to the user
+ assert.equal(host.element('rows').textContent, `读取失败${scenario.error}`);
+ assert.equal(host.network.requests.length, 2);
+ assert.equal(host.element('footer').textContent, '来源：CoinMarketCap 中文页');
+ });
+}
+
+for (const holderKey of ['total', 'count']) {
+ test(`user sees large and negative CMC supply values with the available holder ${holderKey}`, { timeout: 5_000 }, async t => {
+ // Given API details supply large token amounts and an alternate supported holder field
+ const host = createDataPanelHost(t, 'cmc');
+ const detail = cmcDetail({ holders: { [holderKey]: 42 }, profileCompletionScore: { percentage: 'unavailable' }, latestUpdateTime: 'unavailable' });
+ Object.assign(detail.statistics, { totalSupply: 1_200_000_000_000, maxSupply: 300_000_000, circulatingSupply: -20_000 });
+
+ // When detail data succeeds and the dedicated holder endpoint publishes no count
+ await host.start();
+ await completeCmcData(host, detail, { holder: { showFlag: false } });
+
+ // Then unit formatting, negative signs, unavailable fields, and fallback holder identity are preserved
+ const text = host.element('rows').textContent;
+ assert.match(text, /总供应量1\.2万亿 BTC/);
+ assert.match(text, /最大供应量3亿 BTC/);
+ assert.match(text, /流通供应量-2万 BTC/);
+ assert.match(text, /持有者42/);
+ assert.match(text, /Profile score--/);
+ assert.match(host.element('footer').textContent, /CMC -- \/ 拉取/);
+ });
+}
+
+test('user sees explicit unavailable metrics when an otherwise valid CMC response omits statistics fields', { timeout: 5_000 }, async t => {
+ // Given a valid asset detail has no optional statistic, holder, timestamp, or score fields
+ const host = createDataPanelHost(t, 'cmc');
+ const detail = { id: 1, statistics: {} };
+ await host.start();
+
+ // When the detail response renders with no separately published holder count
+ await completeCmcData(host, detail, { holder: { showFlag: false } });
+
+ // Then unavailable values stay visible instead of becoming directional changes or guessed quantities
+ assert.equal(host.element('symbol').textContent, 'BTC');
+ assert.equal([...host.element('rows').children].every(row => row.children[1].textContent === '--'), true);
+ assert.match(host.element('footer').textContent, /CMC -- \/ 拉取/);
+});
+
+test('user retains CMC detail rows when the optional holder endpoint times out', { timeout: 5_000 }, async t => {
+ // Given the map and detail APIs have already succeeded
+ const host = createDataPanelHost(t, 'cmc', { path: '/futures/RAVEUSDT' });
+ await host.start();
+ host.network.requests[0].respond({ data: cmcDetail({ id: 38967, symbol: 'RAVE' }) });
+ const holder = await host.network.waitForRequest(request => request.url.pathname.endsWith('/show_holders'));
+
+ // When only the supplemental holder request times out
+ holder.fail('timeout');
+ await host.rendered(() => host.element('footer').textContent.includes('CMC data-api'));
+
+ // Then the successful valuation details remain visible with an unavailable holder metric
+ assert.match(host.element('rows').textContent, /流通市值\$1\.2万亿/);
+ assert.match(host.element('rows').textContent, /持有者--/);
+ assert.equal(host.element('symbol').textContent, 'RAVE #1');
+});
+
+test('user can force a new CMC refresh while scheduled refreshes avoid duplicating pending work', { timeout: 5_000 }, async t => {
+ // Given a rendered panel has a cached asset mapping
+ const host = createDataPanelHost(t, 'cmc');
+ await host.start();
+ await completeCmcData(host);
+ const detail = cmcDetail({ showTreasuriesFlag: true, treasuryHoldings: 1 });
+
+ // When manual refresh supersedes a pending request while the interval also becomes due
+ host.element('refresh').click();
+ const old = await host.network.waitForRequest(request => !request.settled && request.url.pathname.endsWith('/detail'));
+ const count = host.network.requests.length;
+ host.clock.tick(30_000);
+ assert.equal(host.network.requests.length, count);
+ host.element('refresh').click();
+ const current = await host.network.waitForRequest(request => request !== old && !request.settled && request.url.pathname.endsWith('/detail'));
+ current.respond({ data: { ...detail, statistics: { ...detail.statistics, price: 100 } } });
+ await host.rendered(() => host.element('rows').textContent.includes('价格$100'));
+ old.respond({ data: { ...detail, statistics: { ...detail.statistics, price: 50 } } });
+ await afterDataMediaResponseTurn();
+
+ // Then only the latest forced request controls the panel's visible price
+ assert.match(host.element('rows').textContent, /价格\$100/);
+ assert.doesNotMatch(host.element('rows').textContent, /价格\$50/);
+ assert.equal(host.network.requests.filter(request => request.url.pathname.endsWith('/map')).length, 1);
+});
+
+for (const outcome of ['http', 'network']) {
+ test(`user sees a trading endpoint remain unavailable after its single ${outcome} retry fails`, { timeout: 5_000 }, async t => {
+ // Given the trading panel starts with the current period available at other endpoints
+ const host = createDataPanelHost(t, 'trading');
+ await host.start();
+ host.network.requests[0].respond({ serverTime: Date.now() });
+ const dataset = tradingDataset(Date.now());
+ await completeTradingBatch(host, dataset, { status: { openInterestHist: 503 } });
+ const retry = await host.network.waitForRequest(request => !request.settled && request.url.pathname.endsWith('/openInterestHist'));
+
+ // When the only immediate retry fails through its declared transport result
+ if (outcome === 'http') retry.respond({}, 503);
+ else retry.fail();
+ await host.rendered(panel => panel?.querySelector('[data-role="updated-at"]')?.textContent.startsWith('更新于'));
+
+ // Then that row stays unavailable while unrelated successful endpoints retain their votes
+ assert.equal(host.element('rows').firstElementChild.children[1].textContent, '--');
+ assert.match(host.element('composite').textContent, /偏多 6:0/);
+ assert.equal(host.network.requests.filter(request => request.url.pathname.endsWith('/openInterestHist')).length, 2);
+ });
+}
+
+test('user can render trading data with local time after server synchronization fails', { timeout: 5_000 }, async t => {
+ // Given the server-time endpoint returns an explicit HTTP failure
+ const host = createDataPanelHost(t, 'trading');
+ await host.start();
+
+ // When synchronization fails but the seven data endpoints still succeed
+ host.network.requests[0].respond({}, 500);
+ await completeTradingBatch(host, tradingDataset(Date.now()));
+ await host.rendered(panel => panel?.querySelector('[data-role="updated-at"]')?.textContent.startsWith('更新于'));
+
+ // Then current data remains visible and the local-time recovery reason is recorded
+ assert.match(host.element('composite').textContent, /偏多 7:0/);
+ assert.equal(host.errors.some(args => args.includes('获取服务器时间失败，使用本地时间')), true);
+});
+
+test('user sees no fabricated open-interest trend before enough history is available', { timeout: 5_000 }, async t => {
+ // Given the initial history has only one current open-interest data point
+ const host = createDataPanelHost(t, 'trading');
+ const dataset = tradingDataset(Date.now());
+ dataset.openInterestHist = [dataset.openInterestHist[0]];
+
+ // When the complete trading entrypoint renders this short history
+ await host.start();
+ await activateTradingData(host, dataset);
+
+ // Then the quantity has no directional arrow and only the other six indicators vote
+ assert.equal(host.element('rows').firstElementChild.children[1].textContent, '1.00M');
+ assert.match(host.element('composite').textContent, /偏多 6:0/);
+});
+
+test('user retries only delayed period endpoints after the publication grace interval', { timeout: 5_000 }, async t => {
+ // Given the page opens on a new boundary while the exchange still serves the prior period
+ const host = createDataPanelHost(t, 'trading');
+ const old = tradingDataset(Date.now() - 300_000);
+ await host.start();
+ await activateTradingData(host, old);
+ host.clock.tick(5_000);
+ const mixed = tradingDataset(Date.now());
+ mixed.basis = old.basis;
+ mixed.takerlongshortRatio = old.takerlongshortRatio;
+ await completeTradingBatch(host, mixed);
+ await afterDataMediaResponseTurn();
+ const count = host.network.requests.length;
+
+ // When the first retry deadline arrives and the two delayed endpoints catch up
+ host.clock.tick(9_999);
+ assert.equal(host.network.requests.length, count);
+ host.clock.tick(1);
+ const pending = host.network.requests.filter(request => !request.settled);
+ const current = tradingDataset(Date.now());
+ pending.forEach(request => request.respond(current[request.url.pathname.split('/').at(-1)]));
+ await afterDataMediaResponseTurn();
+
+ // Then the retry fetches only the pending period endpoints and keeps funding untouched
+ assert.deepEqual(pending.map(request => request.url.pathname.split('/').at(-1)).sort(), ['basis', 'takerlongshortRatio']);
+ assert.equal(host.network.requests.filter(request => request.url.pathname.endsWith('/fundingRate')).length, 2);
+ assert.match(host.element('composite').textContent, /偏多 7:0/);
+});
+
+test('user keeps valid trading metrics visible while retrying their missing publication timestamp', { timeout: 5_000 }, async t => {
+ // Given the basis endpoint supplies a valid metric without the current period timestamp
+ const host = createDataPanelHost(t, 'trading');
+ const dataset = tradingDataset(Date.now());
+ delete dataset.basis[0].timestamp;
+ await host.start();
+ await activateTradingData(host, dataset);
+ host.clock.tick(5_000);
+ await completeTradingBatch(host, dataset);
+ await afterDataMediaResponseTurn();
+ const count = host.network.requests.length;
+ assert.match(host.element('composite').textContent, /偏多 7:0/);
+
+ // When only the timestamp-less endpoint reaches its retry deadline and publishes a fresh value
+ host.clock.tick(9_999);
+ assert.equal(host.network.requests.length, count);
+ host.clock.tick(1);
+ const pending = host.network.requests.filter(request => !request.settled);
+ assert.deepEqual(pending.map(request => request.url.pathname.split('/').at(-1)), ['basis']);
+ pending[0].respond([{ timestamp: Date.now(), basisRate: '-0.02' }]);
+ await afterDataMediaResponseTurn();
+
+ // Then the fresh basis value changes its vote without retrying already current endpoints
+ assert.match(host.element('composite').textContent, /偏多 6:1/);
+ assert.equal(host.network.requests.length, count + 1);
+ assert.equal(host.network.requests.filter(request => request.url.pathname.endsWith('/fundingRate')).length, 2);
+});
+
+test('user receives the documented bounded retry schedule while period data remains delayed', { timeout: 5_000 }, async t => {
+ // Given a new cycle repeatedly receives the previous period's six endpoint timestamps
+ const host = createDataPanelHost(t, 'trading');
+ const stale = tradingDataset(Date.now() - 300_000);
+ await host.start();
+ await activateTradingData(host, stale);
+ host.clock.tick(5_000);
+ await completeTradingBatch(host, stale);
+ await afterDataMediaResponseTurn();
+ const observed = [];
+
+ // When each explicit retry deadline is reached without advancing endpoint timestamps
+ for (const delay of [10_000, 15_000, 20_000, 30_000]) {
+ const before = host.network.requests.length;
+ host.clock.tick(delay - 1);
+ assert.equal(host.network.requests.length, before);
+ host.clock.tick(1);
+ const requests = host.network.requests.filter(request => !request.settled);
+ observed.push({ delay, count: requests.length });
+ requests.forEach(request => request.respond(stale[request.url.pathname.split('/').at(-1)]));
+ await afterDataMediaResponseTurn();
+ }
+
+ // Then retries use ten, fifteen, twenty, and thirty seconds with no funding re-fetch
+ assert.deepEqual(observed, [10_000, 15_000, 20_000, 30_000].map(delay => ({ delay, count: 6 })));
+ assert.equal(host.network.requests.filter(request => request.url.pathname.endsWith('/fundingRate')).length, 2);
+});
+
+test('user stops retrying an expired period and resumes at the next publication window', { timeout: 5_000 }, async t => {
+ // Given installation occurs twenty seconds before the current period expires
+ const boundary = Date.UTC(2026, 8, 16);
+ const host = createDataPanelHost(t, 'trading', { now: boundary + 280_000 });
+ const stale = tradingDataset(boundary - 300_000);
+ await host.start();
+ await activateTradingData(host, stale);
+ host.clock.tick(0);
+ await completeTradingBatch(host, stale);
+ await afterDataMediaResponseTurn();
+ host.clock.tick(10_000);
+ host.network.requests.filter(request => !request.settled).forEach(request => request.respond(stale[request.url.pathname.split('/').at(-1)]));
+ await afterDataMediaResponseTurn();
+ const count = host.network.requests.length;
+
+ // When the old window closes and the next boundary's five-second grace elapses
+ host.clock.tick(14_999);
+ assert.equal(host.network.requests.length, count);
+ host.clock.tick(1);
+ await completeTradingBatch(host, tradingDataset(Date.now()));
+ await afterDataMediaResponseTurn();
+
+ // Then one complete new-period batch replaces further retries of the expired window
+ assert.equal(host.network.requests.length, count + 7);
+ assert.equal(host.network.requests.filter(request => request.url.pathname.endsWith('/fundingRate')).length, 3);
+ assert.match(host.element('composite').textContent, /偏多 7:0/);
+});
diff --git a/test/dom/binance-orderbook-trade/account-orders.test.js b/test/dom/binance-orderbook-trade/account-orders.test.js
index 6738004..cc03587 100644
--- a/test/dom/binance-orderbook-trade/account-orders.test.js
+++ b/test/dom/binance-orderbook-trade/account-orders.test.js
@@ -7,12 +7,16 @@ import {
findAccountOrdersTabByIdentity,
findAccountPositionTab,
findOpenOrdersBasicSubTab,
+ findOpenOrdersConditionalSubTab,
findOpenOrdersSubTabByIdentity,
findOpenOrdersTab,
+ findSelectedAccountOrdersTab,
findSelectedOpenOrdersSubTab,
+ getAccountOrdersTabGroup,
getAccountOrdersTabIdentity,
getActiveOpenOrdersScope,
getOpenOrdersSubTabIdentity,
+ isAccountOrdersTab,
parseAccountPositionTabCount,
waitForAccountOrdersMutationState,
} from '../../../src/binance-orderbook-trade/dom/account-orders.js';
@@ -21,15 +25,19 @@ import { isVisibleElement, loadFixtureDom } from '../../helpers/dom.js';
const openOrdersHtml = await readFile(new URL('../../fixtures/binance-orderbook-trade/account-orders-open-orders.html', import.meta.url), 'utf8');
const positionHtml = await readFile(new URL('../../fixtures/binance-orderbook-trade/account-orders-position.html', import.meta.url), 'utf8');
-test('selects the bottom account-orders open-orders tab over unrelated tab groups', () => {
+test("user selects the bottom account-orders open-orders tab over unrelated tab groups", () => {
+ // Given native account tabs and order panes are mounted
const { window } = loadFixtureDom(openOrdersHtml);
+ // When the current account and order scope is resolved
const tab = findOpenOrdersTab(window.document, { isVisibleElement });
+ // Then selects the bottom account-orders open-orders tab over unrelated tab groups
assert.equal(tab?.textContent.trim(), '当前委托(2)');
assert.equal(tab?.closest('#account-orders') != null, true);
});
-test('reads a confirmed zero position count from the unique account tab group', () => {
+test("user reads a confirmed zero position count from the unique account tab group", () => {
+ // Given native account tabs and order panes are mounted
const { window } = loadFixtureDom(`
@@ -42,15 +50,18 @@ test('reads a confirmed zero position count from the unique account tab group',
`);
+ // When the current account and order scope is resolved
const tab = findAccountPositionTab(window.document, { isVisibleElement });
+ // Then reads a confirmed zero position count from the unique account tab group
assert.equal(tab?.textContent.trim(), '仓位(0)');
assert.equal(parseAccountPositionTabCount(tab?.textContent), 0);
assert.equal(parseAccountPositionTabCount('Positions (12)'), 12);
assert.equal(parseAccountPositionTabCount('仓位'), null);
});
-test('rejects position counts when account tab groups are ambiguous', () => {
+test("user rejects position counts when account tab groups are ambiguous", () => {
+ // Given native account tabs and order panes are mounted
const accountGroup = (id) => `
@@ -64,44 +75,58 @@ test('rejects position counts when account tab groups are ambiguous', () => {
`;
const { window } = loadFixtureDom(`${accountGroup('first')}${accountGroup('second')}`);
- assert.equal(findAccountPositionTab(window.document, { isVisibleElement }), null);
+ // When the current account and order scope is resolved
+ const observed = findAccountPositionTab(window.document, { isVisibleElement });
+
+ // Then rejects position counts when account tab groups are ambiguous
+ assert.equal(observed, null);
});
-test('does not trust aria-controls alone when resolving current-orders pane', () => {
+test("user does not trust aria-controls alone when resolving current-orders pane", () => {
+ // Given native account tabs and order panes are mounted
const { window } = loadFixtureDom(openOrdersHtml);
+ // When the current account and order scope is resolved
const scope = getActiveOpenOrdersScope(window.document, {
isVisibleElement,
findHideOtherSymbolCheckbox: (root) => root.querySelector('[role="checkbox"][name="hideOtherSymbol"]'),
findCurrentSymbolCancelAllButton: (root) => Array.from(root.querySelectorAll('button')).find((button) => button.textContent.trim() === '全撤') || null,
});
+ // Then does not trust aria-controls alone when resolving current-orders pane
assert.equal(scope?.id, 'OPEN_ORDERS');
assert.equal(scope.querySelector('#wrong-pane'), null);
});
-test('rejects ambiguous visible OPEN_ORDERS panes', () => {
+test("user rejects ambiguous visible OPEN_ORDERS panes", () => {
+ // Given native account tabs and order panes are mounted
const { window } = loadFixtureDom(`${openOrdersHtml}`);
+ // When the current account and order scope is resolved
const scope = getActiveOpenOrdersScope(window.document, {
isVisibleElement,
findHideOtherSymbolCheckbox: (root) => root.querySelector('[role="checkbox"][name="hideOtherSymbol"]'),
findCurrentSymbolCancelAllButton: (root) => Array.from(root.querySelectorAll('button')).find((button) => button.textContent.trim() === '全撤') || null,
});
+ // Then rejects ambiguous visible OPEN_ORDERS panes
assert.equal(scope, null);
});
-test('returns no active open-orders scope when current-orders tab is not active', () => {
+test("user returns no active open-orders scope when current-orders tab is not active", () => {
+ // Given native account tabs and order panes are mounted
const { window } = loadFixtureDom(positionHtml);
+ // When the current account and order scope is resolved
const scope = getActiveOpenOrdersScope(window.document, {
isVisibleElement,
findHideOtherSymbolCheckbox: (root) => root.querySelector('[role="checkbox"][name="hideOtherSymbol"]'),
findCurrentSymbolCancelAllButton: (root) => Array.from(root.querySelectorAll('button')).find((button) => button.textContent.trim() === '全撤') || null,
});
+ // Then returns no active open-orders scope when current-orders tab is not active
assert.equal(scope, null);
});
-test('does not treat stale position content as active open-orders scope', () => {
+test("user does not treat stale position content as active open-orders scope", () => {
+ // Given native account tabs and order panes are mounted
const { window } = loadFixtureDom(`
@@ -118,16 +143,19 @@ test('does not treat stale position content as active open-orders scope', () =>
`);
+ // When the current account and order scope is resolved
const scope = getActiveOpenOrdersScope(window.document, {
isVisibleElement,
findHideOtherSymbolCheckbox: (root) => root.querySelector('[role="checkbox"][name="hideOtherSymbol"]'),
findCurrentSymbolCancelAllButton: (root) => Array.from(root.querySelectorAll('button')).find((button) => button.textContent.trim() === '全撤') || null,
});
+ // Then does not treat stale position content as active open-orders scope
assert.equal(scope, null);
});
-test('finds basic open-orders sub tab when conditional sub tab is selected', () => {
+test("user finds basic open-orders sub tab when conditional sub tab is selected", () => {
+ // Given native account tabs and order panes are mounted
const { window } = loadFixtureDom(`
@@ -151,13 +179,16 @@ test('finds basic open-orders sub tab when conditional sub tab is selected', ()
findCurrentSymbolCancelAllButton: (root) => Array.from(root.querySelectorAll('button')).find((button) => button.textContent.trim() === '全撤') || null,
});
const basicTab = findOpenOrdersBasicSubTab(scope, { isVisibleElement });
+ // When the current account and order scope is resolved
const selectedSubTab = findSelectedOpenOrdersSubTab(scope, { isVisibleElement });
+ // Then finds basic open-orders sub tab when conditional sub tab is selected
assert.equal(basicTab?.textContent.trim(), '基础单(5)');
assert.equal(selectedSubTab?.textContent.trim(), '条件委托(0)');
});
-test('finds the verified English Basic and Conditional labels with live counts', () => {
+test("user finds the verified English Basic and Conditional labels with live counts", () => {
+ // Given native account tabs and order panes are mounted
const { window } = loadFixtureDom(`
@@ -175,6 +206,7 @@ test('finds the verified English Basic and Conditional labels with live counts',
`);
+ // When the current account and order scope is resolved
const scope = getActiveOpenOrdersScope(window.document, {
isVisibleElement,
findHideOtherSymbolCheckbox: (root) => root.querySelector('[role="checkbox"][name="hideOtherSymbol"]'),
@@ -182,6 +214,7 @@ test('finds the verified English Basic and Conditional labels with live counts',
.find((button) => button.textContent.trim() === 'Cancel All') || null,
});
+ // Then finds the verified English Basic and Conditional labels with live counts
assert.equal(
findOpenOrdersBasicSubTab(scope, { isVisibleElement })?.textContent.trim(),
'Basic(31)',
@@ -192,7 +225,8 @@ test('finds the verified English Basic and Conditional labels with live counts',
);
});
-test('reacquires account and open-orders tabs by semantic identity after rerender', () => {
+test("user reacquires account and open-orders tabs by semantic identity after rerender", () => {
+ // Given native account tabs and order panes are mounted
const { window } = loadFixtureDom(openOrdersHtml);
const selectedAccountTab = window.document.querySelector('#account-orders [role="tab"][aria-selected="true"]');
const accountIdentity = getAccountOrdersTabIdentity(selectedAccountTab);
@@ -200,7 +234,9 @@ test('reacquires account and open-orders tabs by semantic identity after rerende
replacementAccountTab.textContent = '当前委托(7)';
selectedAccountTab.replaceWith(replacementAccountTab);
+ // When the current account and order scope is resolved
const accountTab = findAccountOrdersTabByIdentity(window.document, accountIdentity, { isVisibleElement });
+ // Then reacquires account and open-orders tabs by semantic identity after rerender
assert.equal(selectedAccountTab.isConnected, false);
assert.notEqual(accountTab, selectedAccountTab);
assert.equal(accountTab?.textContent.trim(), '当前委托(7)');
@@ -222,7 +258,8 @@ test('reacquires account and open-orders tabs by semantic identity after rerende
assert.equal(subTab?.textContent.trim(), '条件委托(3)');
});
-test('mutation wait survives replacement of the OPEN_ORDERS subtree', async () => {
+test("user waits through replacement of the OPEN_ORDERS subtree", async () => {
+ // Given native account tabs and order panes are mounted
const { window } = loadFixtureDom(openOrdersHtml);
const observationRoot = window.document.querySelector('#account-orders');
const oldScope = window.document.querySelector('#OPEN_ORDERS');
@@ -234,39 +271,45 @@ test('mutation wait survives replacement of the OPEN_ORDERS subtree', async () =
const replacementScope = oldScope.cloneNode(true);
replacementScope.dataset.ready = 'true';
+ // When the current account and order scope is resolved
oldScope.replaceWith(replacementScope);
const resolvedScope = await wait;
+ // Then sees that mutation wait survives replacement of the OPEN_ORDERS subtree
assert.equal(oldScope.isConnected, false);
assert.equal(resolvedScope, replacementScope);
});
-test('mutation wait reacts when Binance updates row text in place', async () => {
+test("user reacts to native row text changes without advancing the mutation deadline", async (t) => {
+ // Given native account tabs and order panes are mounted
const { window } = loadFixtureDom(openOrdersHtml);
const observationRoot = window.document.querySelector('#account-orders');
const scope = window.document.querySelector('#OPEN_ORDERS');
const marker = window.document.createElement('span');
marker.textContent = 'loading';
scope.append(marker);
+ t.mock.timers.enable({ apis: ['Date', 'setTimeout'], now: 1000 });
const wait = waitForAccountOrdersMutationState(
observationRoot,
() => marker.textContent === 'ready' ? marker : null,
200,
);
- const startedAt = Date.now();
+ // When the current account and order scope is resolved
marker.firstChild.data = 'ready';
+ // Then sees that mutation wait reacts when Binance updates row text in place
assert.equal(await wait, marker);
- assert.ok(Date.now() - startedAt < 100, 'characterData should resolve through the observer, not timeout');
+ assert.equal(Date.now(), 1000);
});
-test('mutation wait aborts immediately with the caller-provided reason', async () => {
+test("user aborts a pending mutation wait with the caller-provided reason", async (t) => {
+ // Given native account tabs and order panes are mounted
const { window } = loadFixtureDom(openOrdersHtml);
const observationRoot = window.document.querySelector('#account-orders');
const controller = new AbortController();
const reason = new Error('ladder stopped');
- const startedAt = Date.now();
+ t.mock.timers.enable({ apis: ['Date', 'setTimeout'], now: 1000 });
const wait = waitForAccountOrdersMutationState(
observationRoot,
() => null,
@@ -274,22 +317,308 @@ test('mutation wait aborts immediately with the caller-provided reason', async (
controller.signal,
);
+ // When the current account and order scope is resolved
controller.abort(reason);
+ // Then sees that mutation wait aborts immediately with the caller-provided reason
await assert.rejects(wait, (error) => error === reason);
- assert.ok(Date.now() - startedAt < 100, 'abort should not wait for the mutation deadline');
+ assert.equal(Date.now(), 1000);
});
-test('account-orders mutation signal wakes once for a relevant subtree change', async () => {
+test("user sees that account-orders mutation signal wakes once for a relevant subtree change", async () => {
+ // Given native account tabs and order panes are mounted
const { window } = loadFixtureDom(openOrdersHtml);
const observationRoot = window.document.querySelector('#account-orders');
const signal = createAccountOrdersMutationSignal(observationRoot);
const version = signal.version;
const wait = signal.waitForChange(version, 200);
+ // When the current account and order scope is resolved
window.document.querySelector('#OPEN_ORDERS').classList.add('ready');
+ // Then sees that account-orders mutation signal wakes once for a relevant subtree change
assert.equal(await wait, 'changed');
assert.ok(signal.version > version);
signal.dispose();
});
+
+test('user receives an already delivered account mutation without waiting for another event', async () => {
+ // Given a real mutation signal and an independent observer watch the mounted account section
+ const { window } = loadFixtureDom(openOrdersHtml);
+ const root = window.document.querySelector('#account-orders');
+ const signal = createAccountOrdersMutationSignal(root);
+ const previousVersion = signal.version;
+ const delivered = Promise.withResolvers();
+ const observer = new window.MutationObserver((mutations) => {
+ observer.disconnect();
+ delivered.resolve(mutations);
+ });
+ observer.observe(root, { attributes: true });
+ root.classList.add('native-ready');
+ const mutations = await delivered.promise;
+
+ // When a consumer starts waiting from the version preceding that delivery
+ const result = await signal.waitForChange(previousVersion, 1000);
+
+ // Then the known mutation is reported immediately with one advanced version
+ assert.equal(mutations[0].attributeName, 'class');
+ assert.equal(result, 'changed');
+ assert.equal(signal.version, previousVersion + 1);
+ signal.dispose();
+});
+
+test('user reaches the account mutation timeout only at its virtual deadline', async (t) => {
+ // Given a mounted account section has no pending native changes
+ const { window } = loadFixtureDom(openOrdersHtml);
+ const signal = createAccountOrdersMutationSignal(window.document.querySelector('#account-orders'));
+ t.mock.timers.enable({ apis: ['setTimeout'] });
+ let result = 'pending';
+ const pending = signal.waitForChange(signal.version, 50).then((value) => { result = value; return value; });
+
+ // When the virtual clock advances to just before the deadline
+ t.mock.timers.tick(49);
+ await Promise.resolve();
+
+ // Then the unchanged account remains pending
+ assert.equal(result, 'pending');
+ assert.equal(signal.version, 0);
+
+ // When the final millisecond reaches the explicit deadline
+ t.mock.timers.tick(1);
+ const outcome = await pending;
+
+ // Then the signal resolves once with timeout and no synthetic mutation
+ assert.equal(outcome, 'timeout');
+ assert.equal(result, 'timeout');
+ assert.equal(signal.version, 0);
+ signal.dispose();
+});
+
+test('user disposes an account mutation wait and disconnects later DOM observations', async () => {
+ // Given a consumer is waiting while another observer can verify later DOM delivery
+ const { window } = loadFixtureDom(openOrdersHtml);
+ const root = window.document.querySelector('#account-orders');
+ const signal = createAccountOrdersMutationSignal(root);
+ const pending = signal.waitForChange(signal.version, 1000);
+ const delivered = Promise.withResolvers();
+ const observer = new window.MutationObserver((mutations) => {
+ observer.disconnect();
+ delivered.resolve(mutations);
+ });
+ observer.observe(root, { childList: true });
+
+ // When cleanup runs before native page content changes again
+ signal.dispose();
+ root.append(window.document.createElement('span'));
+ const [outcome, mutations] = await Promise.all([pending, delivered.promise]);
+
+ // Then cleanup releases the waiter and later delivered mutations do not increment its version
+ assert.equal(outcome, 'disposed');
+ assert.equal(mutations[0].addedNodes[0].tagName, 'SPAN');
+ assert.equal(signal.version, 0);
+});
+
+test('user reads an already available account state without requiring an observation root', async () => {
+ // Given the requested native pane is already present in the document
+ const { window } = loadFixtureDom(openOrdersHtml);
+ const pane = window.document.querySelector('#OPEN_ORDERS');
+
+ // When the state waiter checks the current DOM before installing observation
+ const result = await waitForAccountOrdersMutationState(null, () => window.document.querySelector('#OPEN_ORDERS'), 1000);
+
+ // Then the exact current pane is returned despite the absent observer root
+ assert.equal(result, pane);
+});
+
+test('user gets no mutation state when the observation root is unavailable', async () => {
+ // Given the document contains no account order state or observable root
+ const { window } = loadFixtureDom('');
+
+ // When the signal and state waiter are created without an account root
+ const signal = createAccountOrdersMutationSignal(null);
+ const result = await waitForAccountOrdersMutationState(null, () => window.document.querySelector('#OPEN_ORDERS'), 1000);
+
+ // Then observation remains unavailable without inventing a state
+ assert.equal(signal, null);
+ assert.equal(result, null);
+});
+
+test('user gets the final absent account state when the virtual mutation deadline expires', async (t) => {
+ // Given an observable account section has not mounted the requested ready marker
+ const { window } = loadFixtureDom(openOrdersHtml);
+ const root = window.document.querySelector('#account-orders');
+ t.mock.timers.enable({ apis: ['Date', 'setTimeout'], now: 1000 });
+ let outcome = 'pending';
+ const pending = waitForAccountOrdersMutationState(root, () => root.querySelector('[data-ready]'), 50)
+ .then((value) => { outcome = value; return value; });
+
+ // When the deadline has not yet elapsed
+ t.mock.timers.tick(49);
+ await Promise.resolve();
+
+ // Then the caller still waits for the real account marker
+ assert.equal(outcome, 'pending');
+
+ // When the clock reaches the account wait deadline
+ t.mock.timers.tick(1);
+ const result = await pending;
+
+ // Then a final DOM read returns null at the exact deadline
+ assert.equal(result, null);
+ assert.equal(outcome, null);
+ assert.equal(Date.now(), 1050);
+});
+
+test('user rejects a pre-aborted account wait before reading or observing state', async () => {
+ // Given cancellation already carries the caller's specific failure reason
+ const { window } = loadFixtureDom(openOrdersHtml);
+ const controller = new AbortController();
+ const reason = new Error('account workflow stopped');
+ controller.abort(reason);
+ let reads = 0;
+
+ // When the aborted caller requests account state
+ const pending = waitForAccountOrdersMutationState(window.document.body, () => {
+ reads += 1;
+ return window.document.querySelector('#OPEN_ORDERS');
+ }, 1000, controller.signal);
+
+ // Then the original reason propagates before the DOM reader is invoked
+ await assert.rejects(pending, (error) => error === reason);
+ assert.equal(reads, 0);
+});
+
+test('user finds visible conditional and selected basic subtabs while ignoring hidden candidates', () => {
+ // Given the native pane contains hidden stale tabs and current English subtabs
+ const { window } = loadFixtureDom(`
+
+
Conditional(9)
+
Unrelated
+
Basic(2)
+
Conditional(3)
+
+ `);
+ const root = window.document.querySelector('#orders');
+
+ // When subtab discovery reads the current visible controls
+ const conditional = findOpenOrdersConditionalSubTab(root, { isVisibleElement });
+ const selected = findSelectedOpenOrdersSubTab(root, { isVisibleElement });
+ const basicIdentity = getOpenOrdersSubTabIdentity(selected);
+
+ // Then the visible semantic controls determine selection and stable identity
+ assert.equal(conditional.textContent, 'Conditional(3)');
+ assert.equal(selected.textContent, 'Basic(2)');
+ assert.equal(basicIdentity, 'basic');
+});
+
+test('user rejects missing and duplicate subtab identities instead of choosing a stale candidate', () => {
+ // Given two visible basic subtabs share an identity and an unrelated selected tab exists
+ const { window } = loadFixtureDom(`
+
Basic(2)
Basic(3)
+
Other
+ `);
+ const root = window.document.querySelector('section');
+ const unrelated = root.querySelector('[aria-selected="true"]');
+
+ // When semantic resolution sees duplicate, absent, and unsupported subtab identities
+ const duplicate = findOpenOrdersSubTabByIdentity(root, 'basic', { isVisibleElement });
+ const missingRoot = findOpenOrdersSubTabByIdentity(null, 'basic', { isVisibleElement });
+ const missingIdentity = findOpenOrdersSubTabByIdentity(root, null, { isVisibleElement });
+ const conditional = findOpenOrdersConditionalSubTab(root, { isVisibleElement });
+ const selected = findSelectedOpenOrdersSubTab(root, { isVisibleElement });
+ const identity = getOpenOrdersSubTabIdentity(unrelated);
+
+ // Then none of those cases yields a unique supported native subtab
+ assert.equal(duplicate, null);
+ assert.equal(missingRoot, null);
+ assert.equal(missingIdentity, null);
+ assert.equal(conditional, null);
+ assert.equal(selected, null);
+ assert.equal(identity, null);
+});
+
+test('user resolves the selected account tab and rejects duplicate semantic account identities', () => {
+ // Given the account group has one current-orders selection and two position labels
+ const { window } = loadFixtureDom(openOrdersHtml);
+ const group = window.document.querySelector('#account-orders .account-tab-group');
+ group.insertAdjacentHTML('beforeend', '
仓位(1)
');
+
+ // When account selection and the ambiguous position identity are resolved
+ const selected = findSelectedAccountOrdersTab(window.document, { isVisibleElement });
+ const position = findAccountOrdersTabByIdentity(window.document, '仓位', { isVisibleElement });
+ const countTab = findAccountPositionTab(window.document, { isVisibleElement });
+ const missingIdentity = findAccountOrdersTabByIdentity(window.document, null, { isVisibleElement });
+
+ // Then the unique selected orders tab survives while duplicate positions remain unresolved
+ assert.equal(selected.textContent, '当前委托(2)');
+ assert.equal(position, null);
+ assert.equal(countTab, null);
+ assert.equal(missingIdentity, null);
+ assert.equal(getAccountOrdersTabIdentity(null), null);
+});
+
+test('user rejects unrelated and detached tabs that do not belong to an account group', () => {
+ // Given a page only contains an unrelated tab group and a detached native-looking label
+ const { window } = loadFixtureDom('
Open Orders
');
+ const unrelated = window.document.querySelector('[role="tab"]');
+ const detached = window.document.createElement('div');
+ detached.textContent = 'Open Orders';
+
+ // When account ownership and selection are requested for those candidates
+ const related = isAccountOrdersTab(unrelated, { isVisibleElement });
+ const group = getAccountOrdersTabGroup(detached, { isVisibleElement });
+ const selected = findSelectedAccountOrdersTab(window.document, { isVisibleElement });
+ const identity = findAccountOrdersTabByIdentity(window.document, 'open orders', { isVisibleElement });
+
+ // Then no unrelated or detached control can become the account's native order scope
+ assert.equal(related, false);
+ assert.equal(group, null);
+ assert.equal(selected, null);
+ assert.equal(identity, null);
+});
+
+test('user leaves account selection unresolved when no native account tab is selected', () => {
+ // Given the semantic account group is mounted between two native selection updates
+ const { window } = loadFixtureDom(openOrdersHtml);
+ window.document.querySelector('#account-orders [aria-selected="true"]').setAttribute('aria-selected', 'false');
+
+ // When the current selected account tab is read
+ const selected = findSelectedAccountOrdersTab(window.document, { isVisibleElement });
+
+ // Then no selection is inferred from the order of available tabs
+ assert.equal(selected, null);
+});
+
+test('user recognizes an open-order pane from its native filter and basic-order evidence', () => {
+ // Given an empty native pane has its filter and basic subtab but no cancel button
+ const { window } = loadFixtureDom(openOrdersHtml);
+ const pane = window.document.querySelector('#OPEN_ORDERS');
+ pane.querySelector('button').remove();
+ pane.insertAdjacentHTML('afterbegin', '
基础单(0)
');
+
+ // When the active pane is resolved from current native DOM evidence
+ const scope = getActiveOpenOrdersScope(window.document, {
+ isVisibleElement,
+ findHideOtherSymbolCheckbox: (root) => root.querySelector('[name="hideOtherSymbol"]'),
+ findCurrentSymbolCancelAllButton: (root) => root.querySelector('button'),
+ });
+
+ // Then the filter and basic-order label jointly identify the empty native pane
+ assert.equal(scope, pane);
+});
+
+test('user ignores a hidden open-order pane even when its native controls remain mounted', () => {
+ // Given the selected account tab still has a hidden stale order pane
+ const { window } = loadFixtureDom(openOrdersHtml);
+ window.document.querySelector('#OPEN_ORDERS').setAttribute('data-hidden', '');
+
+ // When the current open-orders scope is resolved
+ const scope = getActiveOpenOrdersScope(window.document, {
+ isVisibleElement,
+ findHideOtherSymbolCheckbox: (root) => root.querySelector('[name="hideOtherSymbol"]'),
+ findCurrentSymbolCancelAllButton: (root) => root.querySelector('button'),
+ });
+
+ // Then hidden native controls cannot certify a current order scope
+ assert.equal(scope, null);
+});
diff --git a/test/dom/binance-orderbook-trade/chart-orders.test.js b/test/dom/binance-orderbook-trade/chart-orders.test.js
index eaa20b6..4350dd3 100644
--- a/test/dom/binance-orderbook-trade/chart-orders.test.js
+++ b/test/dom/binance-orderbook-trade/chart-orders.test.js
@@ -62,38 +62,56 @@ function loadChartTarget(options = {}) {
return { dom, tradingViewApi };
}
-test('locates the current chart Open Orders target in TradingView and Basic modes', () => {
- for (const mode of ['tradingview', 'basic']) {
+for (const [scenarioIndex, mode] of (['tradingview', 'basic']).entries()) {
+ test(`user locates the current chart Open Orders target in TradingView and Basic modes (case ${scenarioIndex + 1})`, () => {
+ // Given the native fixture represents this supported scenario
const { dom, tradingViewApi } = loadChartTarget({ mode });
+ // When the real adapter handles this fixture
const target = getBinanceChartOrdersTarget(dom.window.document);
+ // Then the user locates the current chart Open Orders target in TradingView and Basic modes
assert.equal(target.chartRoot.className, 'chart-widget-root');
assert.equal(target.toolbar.getAttribute('data-testid'), 'chart-toolbar');
assert.equal(target.trigger.getAttribute('data-testid'), 'orders-trigger');
assert.equal(target.popoverId, 'chart-orders-menu');
assert.equal(target.tradingViewApi, tradingViewApi);
- }
-});
+ });
+}
-test('supports the English current-price label without broad text scanning', () => {
+test("user supports the English current-price label without broad text scanning", () => {
+ // Given the native chart toolbar and order controls are mounted
const { dom } = loadChartTarget({ latestPriceLabel: 'Last Price' });
+ // When the active chart order controls are inspected
+ const observed = getBinanceChartOrdersTarget(dom.window.document).trigger.getAttribute('data-testid');
+
+ // Then supports the English current-price label without broad text scanning
assert.equal(
- getBinanceChartOrdersTarget(dom.window.document).trigger.getAttribute('data-testid'),
+ observed,
'orders-trigger',
);
});
-test('supports Binance wrapping the current-price control in a contents slot', () => {
+test("user supports Binance wrapping the current-price control in a contents slot", () => {
+ // Given the native chart toolbar and order controls are mounted
const { dom } = loadChartTarget({ wrapLatestPrice: true });
+ // When the active chart order controls are inspected
+ const observed = getBinanceChartOrdersTarget(dom.window.document).trigger.getAttribute('data-testid');
+
+ // Then supports Binance wrapping the current-price control in a contents slot
assert.equal(
- getBinanceChartOrdersTarget(dom.window.document).trigger.getAttribute('data-testid'),
+ observed,
'orders-trigger',
);
});
-test('find waits for a visible complete and unambiguous chart contract', () => {
+test("user sees that find waits for a visible complete and unambiguous chart contract", () => {
+ // Given the native chart toolbar and order controls are mounted
const missingDom = loadFixtureDom('');
- assert.equal(findBinanceChartOrdersTarget(missingDom.window.document), null);
+ // When the active chart order controls are inspected
+ const observed = findBinanceChartOrdersTarget(missingDom.window.document);
+
+ // Then sees that find waits for a visible complete and unambiguous chart contract
+ assert.equal(observed, null);
const hidden = loadChartTarget();
hidden.dom.window.document.querySelector('.chart-widget-root').setAttribute('data-hidden', '');
@@ -116,13 +134,15 @@ test('find waits for a visible complete and unambiguous chart contract', () => {
);
});
-test('finds the trigger-linked Chinese or English Open Orders checkbox', () => {
- for (const label of ['当前委托', 'Open Orders']) {
+for (const [scenarioIndex, label] of (['当前委托', 'Open Orders']).entries()) {
+ test(`user finds the trigger-linked Chinese or English Open Orders checkbox (case ${scenarioIndex + 1})`, () => {
+ // Given the native fixture represents this supported scenario
const { dom } = loadChartTarget();
dom.window.document.body.insertAdjacentHTML(
'beforeend',
createPopoverMarkup({ labels: ['快捷下单', label, '持有仓位'], openOrdersChecked: 'false' }),
);
+ // When the real adapter handles this fixture
const target = getBinanceChartOrdersTarget(dom.window.document);
const result = findActiveBinanceChartOrdersPopover(
dom.window.document,
@@ -130,31 +150,38 @@ test('finds the trigger-linked Chinese or English Open Orders checkbox', () => {
isVisibleElement,
);
+ // Then the user finds the trigger-linked Chinese or English Open Orders checkbox
assert.equal(result.checkbox.textContent.trim(), label);
assert.equal(result.checked, false);
- }
-});
+ });
+}
-test('ignores active lookalike popovers not linked to the chart trigger', () => {
+test("user ignores active lookalike popovers not linked to the chart trigger", () => {
+ // Given the native chart toolbar and order controls are mounted
const { dom } = loadChartTarget();
dom.window.document.body.insertAdjacentHTML(
'beforeend',
createPopoverMarkup({ popoverId: 'another-menu' }),
);
+ // When the active chart order controls are inspected
const target = getBinanceChartOrdersTarget(dom.window.document);
+ // Then ignores active lookalike popovers not linked to the chart trigger
assert.equal(
findActiveBinanceChartOrdersPopover(dom.window.document, target, isVisibleElement),
null,
);
});
-test('invalid or duplicate Open Orders checkboxes fail explicitly', () => {
+test("user sees that invalid or duplicate Open Orders checkboxes fail explicitly", () => {
+ // Given the native chart toolbar and order controls are mounted
const invalid = loadChartTarget();
+ // When the active chart order controls are inspected
invalid.dom.window.document.body.insertAdjacentHTML(
'beforeend',
createPopoverMarkup({ openOrdersChecked: 'mixed' }),
);
+ // Then sees that invalid or duplicate Open Orders checkboxes fail explicitly
assert.throws(
() => findActiveBinanceChartOrdersPopover(
invalid.dom.window.document,
@@ -179,12 +206,15 @@ test('invalid or duplicate Open Orders checkboxes fail explicitly', () => {
);
});
-test('rejects a replaced chart root toolbar trigger or runtime', () => {
+test("user rejects a replaced chart root toolbar trigger or runtime", () => {
+ // Given the native chart toolbar and order controls are mounted
const first = loadChartTarget();
const second = loadChartTarget();
const oldTarget = getBinanceChartOrdersTarget(first.dom.window.document);
+ // When the active chart order controls are inspected
const newTarget = getBinanceChartOrdersTarget(second.dom.window.document);
+ // Then rejects a replaced chart root toolbar trigger or runtime
assert.throws(
() => assertSameBinanceChartOrdersTarget(oldTarget, newTarget),
/图表“显示当前委托”控件已变化/,
diff --git a/test/dom/binance-orderbook-trade/depth-profile.test.js b/test/dom/binance-orderbook-trade/depth-profile.test.js
index 5c1cf7f..cb5a899 100644
--- a/test/dom/binance-orderbook-trade/depth-profile.test.js
+++ b/test/dom/binance-orderbook-trade/depth-profile.test.js
@@ -65,20 +65,29 @@ function installTradingViewApi(frame, {
return scale;
}
-test('finds the visible TradingView frame host', () => {
+test("user finds the visible TradingView frame host", () => {
+ // Given the chart geometry and visible depth levels are available
const dom = createChartDom();
+ // When the current depth display is rendered or resolved
const target = findDepthProfileHost(dom.window.document);
+ // Then finds the visible TradingView frame host
assert.equal(target.chartRoot.className, 'chart-widget-root');
assert.equal(target.host.className, 'h-full relative');
});
-test('returns null while Binance mounts the native depth chart instead of a visible frame', () => {
+test("user returns null while Binance mounts the native depth chart instead of a visible frame", () => {
+ // Given the chart geometry and visible depth levels are available
const dom = createChartDom({ hiddenFrame: true });
- assert.equal(findDepthProfileHost(dom.window.document), null);
+ // When the current depth display is rendered or resolved
+ const observed = findDepthProfileHost(dom.window.document);
+
+ // Then returns null while Binance mounts the native depth chart instead of a visible frame
+ assert.equal(observed, null);
});
-test('does not mount on Binance Basic because it has no verified price-coordinate contract', () => {
+test("user does not mount on Binance Basic because it has no verified price-coordinate contract", () => {
+ // Given the chart geometry and visible depth levels are available
const dom = loadFixtureDom(`
@@ -86,16 +95,23 @@ test('does not mount on Binance Basic because it has no verified price-coordinat
`);
- assert.equal(findDepthProfileHost(dom.window.document), null);
+ // When the current depth display is rendered or resolved
+ const observed = findDepthProfileHost(dom.window.document);
+
+ // Then does not mount on Binance Basic because it has no verified price-coordinate contract
+ assert.equal(observed, null);
});
-test('maps prices through the active TradingView main-pane scale', () => {
+test("user maps prices through the active TradingView main-pane scale", () => {
+ // Given the chart geometry and visible depth levels are available
const dom = createChartDom();
const frame = dom.window.document.querySelector('iframe');
installTradingViewApi(frame);
+ // When the current depth display is rendered or resolved
const geometry = getTradingViewDepthProfileGeometry(frame);
+ // Then maps prices through the active TradingView main-pane scale
assert.equal(geometry.top, 0);
assert.equal(geometry.height, 200);
assert.equal(geometry.rightInset, 88);
@@ -105,7 +121,8 @@ test('maps prices through the active TradingView main-pane scale', () => {
assert.equal(geometry.priceToCoordinate(111), null);
});
-test('maps prices correctly on logarithmic and inverted TradingView scales', () => {
+test("user maps prices correctly on logarithmic and inverted TradingView scales", () => {
+ // Given the chart geometry and visible depth levels are available
const logarithmic = createChartDom();
const logarithmicFrame = logarithmic.window.document.querySelector('iframe');
installTradingViewApi(logarithmicFrame, {
@@ -113,7 +130,9 @@ test('maps prices correctly on logarithmic and inverted TradingView scales', ()
mode: 1,
coordinateToPrice: (coordinate) => 1000 * ((100 / 1000) ** (coordinate / 100)),
});
+ // When the current depth display is rendered or resolved
const logarithmicGeometry = getTradingViewDepthProfileGeometry(logarithmicFrame);
+ // Then maps prices correctly on logarithmic and inverted TradingView scales
assert.equal(logarithmicGeometry.mode, 1);
assert.ok(Math.abs(logarithmicGeometry.priceToCoordinate(Math.sqrt(100_000)) - 50) < 0.02);
@@ -129,8 +148,10 @@ test('maps prices correctly on logarithmic and inverted TradingView scales', ()
assert.ok(Math.abs(invertedGeometry.priceToCoordinate(100) - 50) < 0.02);
});
-test('waits for the native chart model before reading panes and recovers when ready', () => {
+test("user waits for the native chart model before reading panes and recovers when ready", () => {
+ // Given the chart geometry and visible depth levels are available
const frame = createChartDom().window.document.querySelector('iframe');
+ // When the current depth display is rendered or resolved
installTradingViewApi(frame);
const chart = frame.contentWindow.tradingViewApi.activeChart();
frame.contentWindow.tradingViewApi.activeChart = () => chart;
@@ -149,6 +170,7 @@ test('waits for the native chart model before reading panes and recovers when re
assert.equal(ready, true, 'pane access requires a ready model');
return readPanes();
};
+ // Then waits for the native chart model before reading panes and recovers when ready
assert.equal(getTradingViewDepthProfileGeometry(frame), null);
assert.equal(paneReads, 0);
ready = true;
@@ -160,12 +182,13 @@ test('waits for the native chart model before reading panes and recovers when re
assert.equal(paneReads, 2);
});
-test('reuses native scale samples within one geometry without changing binary-search coordinates', () => {
- for (const variant of [
+for (const [scenarioIndex, variant] of ([
{ mode: 0, inverted: false, convert: (y) => 110 - y / 10 },
{ mode: 1, inverted: false, convert: (y) => 1000 * (0.1 ** (y / 200)) },
{ mode: 0, inverted: true, convert: (y) => 90 + y / 10 },
- ]) {
+ ]).entries()) {
+ test(`user reuses native scale samples within one geometry without changing binary-search coordinates (case ${scenarioIndex + 1})`, () => {
+ // Given the native fixture represents this supported scenario
const frame = createChartDom().window.document.querySelector('iframe');
const reads = new Map();
installTradingViewApi(frame, {
@@ -175,6 +198,7 @@ test('reuses native scale samples within one geometry without changing binary-se
return variant.convert(y);
},
});
+ // When the real adapter handles this fixture
const geometry = getTradingViewDepthProfileGeometry(frame);
const prices = Array.from({ length: 1000 }, (_, i) => variant.convert(20 + i * 0.03));
for (const price of prices) {
@@ -188,57 +212,75 @@ test('reuses native scale samples within one geometry without changing binary-se
}
assert.equal(geometry.priceToCoordinate(price), (low + high) / 2);
}
+ // Then the user reuses native scale samples within one geometry without changing binary-search coordinates
assert.equal(Math.max(...reads.values()), 1);
assert.ok(reads.size < prices.length * 13 / 4);
- }
-});
+ });
+}
-test('a new geometry samples the changed native scale instead of reusing the previous frame', () => {
+test("user sees that a new geometry samples the changed native scale instead of reusing the previous frame", () => {
+ // Given the chart geometry and visible depth levels are available
const frame = createChartDom().window.document.querySelector('iframe');
const scale = installTradingViewApi(frame);
const before = getTradingViewDepthProfileGeometry(frame);
const oldY = before.priceToCoordinate(100);
let reads = 0;
scale.coordinateToPrice = (y) => { reads += 1; return 120 - y / 5; };
+ // When the current depth display is rendered or resolved
const after = getTradingViewDepthProfileGeometry(frame);
+ // Then sees that a new geometry samples the changed native scale instead of reusing the previous frame
assert.ok(Math.abs(after.priceToCoordinate(110) - 50) < 0.02);
assert.ok(reads > 5);
assert.ok(Math.abs(oldY - 100) < 0.02);
});
-test('invalid native samples inside the binary search still fail explicitly', () => {
+test("user sees that invalid native samples inside the binary search still fail explicitly", () => {
+ // Given the chart geometry and visible depth levels are available
const frame = createChartDom().window.document.querySelector('iframe');
installTradingViewApi(frame, {
coordinateToPrice: (y) => y === 25 ? NaN : 110 - y / 10,
});
+ // When the current depth display is rendered or resolved
const geometry = getTradingViewDepthProfileGeometry(frame);
+ // Then sees that invalid native samples inside the binary search still fail explicitly
assert.throws(() => geometry.priceToCoordinate(108), /TradingView price coordinate is invalid/);
});
-test('fails closed when the TradingView price-scale adapter is unavailable', () => {
+test("user fails closed when the TradingView price-scale adapter is unavailable", () => {
+ // Given the chart geometry and visible depth levels are available
const dom = createChartDom();
const frame = dom.window.document.querySelector('iframe');
- assert.equal(getTradingViewDepthProfileGeometry(frame), null);
+ // When the current depth display is rendered or resolved
+ const observed = getTradingViewDepthProfileGeometry(frame);
+
+ // Then fails closed when the TradingView price-scale adapter is unavailable
+ assert.equal(observed, null);
frame.contentWindow.tradingViewApi = { activeChart: () => ({}) };
assert.equal(getTradingViewDepthProfileGeometry(frame), null);
});
-test('fails closed when TradingView returns a non-monotonic price transform', () => {
+test("user fails closed when TradingView returns a non-monotonic price transform", () => {
+ // Given the chart geometry and visible depth levels are available
const dom = createChartDom();
const frame = dom.window.document.querySelector('iframe');
+ // When the current depth display is rendered or resolved
installTradingViewApi(frame, {
coordinateToPrice: (coordinate) => (coordinate === 100 ? 111 : 110 - coordinate / 10),
});
+ // Then fails closed when TradingView returns a non-monotonic price transform
assert.equal(getTradingViewDepthProfileGeometry(frame), null);
});
-test('fails closed when the TradingView main-pane price axis is missing or ambiguous', () => {
+test("user fails closed when the TradingView main-pane price axis is missing or ambiguous", () => {
+ // Given the chart geometry and visible depth levels are available
const missing = createChartDom();
const missingFrame = missing.window.document.querySelector('iframe');
installTradingViewApi(missingFrame);
+ // When the current depth display is rendered or resolved
missingFrame.contentDocument.querySelector('.price-axis-container').remove();
+ // Then fails closed when the TradingView main-pane price axis is missing or ambiguous
assert.equal(getTradingViewDepthProfileGeometry(missingFrame), null);
const ambiguous = createChartDom();
@@ -257,24 +299,30 @@ test('fails closed when the TradingView main-pane price axis is missing or ambig
assert.equal(getTradingViewDepthProfileGeometry(ambiguousFrame), null);
});
-test('rejects ambiguous visible chart roots', () => {
+test("user rejects ambiguous visible chart roots", () => {
+ // Given the chart geometry and visible depth levels are available
const first = createChartDom();
const secondRoot = first.window.document.querySelector('.chart-widget-root').cloneNode(true);
+ // When the current depth display is rendered or resolved
first.window.document.body.appendChild(secondRoot);
+ // Then rejects ambiguous visible chart roots
assert.throws(
() => findDepthProfileHost(first.window.document),
/Visible chart root count is invalid: 2/,
);
});
-test('creates a non-interactive canvas with an independently clickable toggle', () => {
+test("user creates a non-interactive canvas with an independently clickable toggle", () => {
+ // Given the chart geometry and visible depth levels are available
const dom = createChartDom();
const { document } = dom.window;
const { host } = findDepthProfileHost(document);
let toggles = 0;
+ // When the current depth display is rendered or resolved
const root = ensureDepthProfileView(document, host, { onToggle: () => { toggles += 1; } });
+ // Then creates a non-interactive canvas with an independently clickable toggle
assert.equal(root.id, DEPTH_PROFILE_ID);
assert.equal(root.parentElement, host);
const styleText = document.getElementById('jh-binance-depth-profile-style').textContent;
@@ -296,18 +344,21 @@ test('creates a non-interactive canvas with an independently clickable toggle',
assert.equal(toggles, 1);
});
-test('updates expanded state and removes the view', () => {
+test("user updates expanded state and removes the view", () => {
+ // Given the chart geometry and visible depth levels are available
const dom = createChartDom();
const { document } = dom.window;
const { host } = findDepthProfileHost(document);
const root = ensureDepthProfileView(document, host, { onToggle: () => {} });
+ // When the current depth display is rendered or resolved
setDepthProfileViewState(root, {
expanded: false,
expandedLabel: 'Hide depth profile',
collapsedLabel: 'D',
status: 'Connecting',
});
+ // Then updates expanded state and removes the view
assert.equal(root.dataset.expanded, 'false');
assert.equal(root.querySelector('[data-depth-profile-toggle]').textContent, 'D');
assert.equal(root.querySelector('.jh-depth-profile-status').textContent, 'Connecting');
@@ -316,7 +367,8 @@ test('updates expanded state and removes the view', () => {
assert.equal(document.getElementById(DEPTH_PROFILE_ID), null);
});
-test('reapplying the same view state does not create observer churn', async () => {
+test("user sees that reapplying the same view state does not create observer churn", async () => {
+ // Given the chart geometry and visible depth levels are available
const dom = createChartDom();
const { document, MutationObserver } = dom.window;
const { host } = findDepthProfileHost(document);
@@ -336,14 +388,18 @@ test('reapplying the same view state does not create observer churn', async () =
setDepthProfileViewState(root, state);
await Promise.resolve();
+ // When the current depth display is rendered or resolved
observer.disconnect();
+ // Then sees that reapplying the same view state does not create observer churn
assert.equal(mutations.length, 0);
});
-test('draws bid and ask bars plus the latest-trade divider', () => {
+test("user draws bid and ask bars plus the latest-trade divider", () => {
+ // Given the chart geometry and visible depth levels are available
const dom = createChartDom();
const { document } = dom.window;
const { host } = findDepthProfileHost(document);
+ // When the current depth display is rendered or resolved
const root = ensureDepthProfileView(document, host, { onToggle: () => {} });
const calls = [];
const fillStyles = [];
@@ -371,6 +427,7 @@ test('draws bid and ask bars plus the latest-trade divider', () => {
inverted: false,
priceToCoordinate: (price) => ({ 100: 180, 100.5: 140, 101: 80 }[price] ?? null),
};
+ // Then draws bid and ask bars plus the latest-trade divider
assert.equal(renderDepthProfile(root, {
minPrice: 99,
maxPrice: 102,
@@ -398,7 +455,8 @@ test('draws bid and ask bars plus the latest-trade divider', () => {
assert.deepEqual(calls, ['save', 'setTransform', 'clearRect', 'restore']);
});
-test('draws one bar per visible CSS pixel row and scales width to visible depth', () => {
+test("user draws one bar per visible CSS pixel row and scales width to visible depth", () => {
+ // Given the chart geometry and visible depth levels are available
const dom = createChartDom();
const { document } = dom.window;
const { host } = findDepthProfileHost(document);
@@ -431,6 +489,7 @@ test('draws one bar per visible CSS pixel row and scales width to visible depth'
102: 80.4,
}[price] ?? null),
};
+ // When the current depth display is rendered or resolved
renderDepthProfile(root, {
maxCumulative: 1_000,
bids: [{ price: 99, quantity: 4, cumulative: 4 }],
@@ -441,6 +500,7 @@ test('draws one bar per visible CSS pixel row and scales width to visible depth'
],
}, geometry, 100);
+ // Then draws one bar per visible CSS pixel row and scales width to visible depth
assert.equal(fillRects.length, 2);
assert.deepEqual(fillRects.map(([, y, , height]) => [y, height]), [[80, 1], [180, 1]]);
assert.equal(fillRects[0][0], 0);
@@ -500,14 +560,17 @@ function depthLevels(entries) {
});
}
-test('labels the complete visible pixel-row quantity, not its last level or offscreen cumulative depth', () => {
+test("user labels the complete visible pixel-row quantity, not its last level or offscreen cumulative depth", () => {
+ // Given the chart geometry and visible depth levels are available
const view = createLabelRenderer({ coordinates: { 99: 180.4, 101: 80.2, 102: 80.4 } });
+ // When the current depth display is rendered or resolved
view.render({
maxCumulative: 1_000,
bids: depthLevels([[99, 4]]),
asks: depthLevels([[101, 3], [102, 5], [110, 992]]),
});
+ // Then labels the complete visible pixel-row quantity, not its last level or offscreen cumulative depth
assert.deepEqual(view.labels.map(({ text }) => text), ['101–102 · 8', '99 · 4']);
assert.deepEqual(view.rectangles.filter(({ height }) => height === 1), [
{ x: 0, y: 80, width: 132, height: 1, color: '#f6465d' },
@@ -515,23 +578,29 @@ test('labels the complete visible pixel-row quantity, not its last level or offs
]);
});
-test('chooses at most two large quantity steps per side instead of the largest cumulative bars', () => {
+test("user chooses at most two large quantity steps per side instead of the largest cumulative bars", () => {
+ // Given the chart geometry and visible depth levels are available
const view = createLabelRenderer({ coordinates: { 99: 220, 101: 180, 102: 160, 103: 140, 104: 120, 105: 100, 106: 80 } });
+ // When the current depth display is rendered or resolved
view.render({
bids: depthLevels([[99, 1]]),
asks: depthLevels([[101, 300], [102, 5], [103, 200], [104, 4], [105, 100], [106, 3]]),
});
+ // Then chooses at most two large quantity steps per side instead of the largest cumulative bars
assert.deepEqual(view.labels.map(({ text }) => text), ['101 · 300', '103 · 200']);
});
-test('uses quantity-only text when a complete price band is too wide and keeps every label inside the canvas', () => {
+test("user uses quantity-only text when a complete price band is too wide and keeps every label inside the canvas", () => {
+ // Given the chart geometry and visible depth levels are available
const view = createLabelRenderer({ coordinates: { 0.00010001: 80.2, 0.00010002: 80.4, 0.00009: 180 } });
+ // When the current depth display is rendered or resolved
view.render({
bids: depthLevels([[0.00009, 620_000]]),
asks: depthLevels([[0.00010001, 2_400_000], [0.00010002, 1_400_000]]),
});
+ // Then uses quantity-only text when a complete price band is too wide and keeps every label inside the canvas
assert.deepEqual(view.labels.map(({ text }) => text), ['3.8M', '620K']);
for (const box of view.rectangles.filter(({ height }) => height === 16)) {
assert.ok(box.width <= 88);
@@ -541,44 +610,57 @@ test('uses quantity-only text when a complete price band is too wide and keeps e
assert.deepEqual(view.rectangles.filter(({ height }) => height === 16).map(({ width }) => width), [30, 30]);
});
-test('formats quantities without trailing zeroes, unit-boundary errors, or rounding small nonzero amounts to zero', () => {
- const view = createLabelRenderer({ coordinates: { 101: 80 } });
- for (const [quantity, expected] of [[2_400_000, '101 · 2.4M'], [999_950, '101 · 1M'], [0.00002, '101 · 0.00002']]) {
+for (const [scenarioIndex, [quantity, expected]] of ([[2_400_000, '101 · 2.4M'], [999_950, '101 · 1M'], [0.00002, '101 · 0.00002']]).entries()) {
+ test(`user formats quantities without trailing zeroes, unit-boundary errors, or rounding small nonzero amounts to zero (case ${scenarioIndex + 1})`, () => {
+ // Given the native fixture represents this supported scenario
+ const view = createLabelRenderer({ coordinates: { 101: 80 } });
+
+ // When the real adapter handles this fixture
view.render({ bids: [], asks: depthLevels([[101, quantity]]) });
+ // Then the user formats quantities without trailing zeroes, unit-boundary errors, or rounding small nonzero amounts to zero
assert.deepEqual(view.labels.map(({ text }) => text), [expected]);
- }
-});
+ });
+}
-test('keeps nearby labels apart and does not cover the current-price divider', () => {
+test("user keeps nearby labels apart and does not cover the current-price divider", () => {
+ // Given the chart geometry and visible depth levels are available
const view = createLabelRenderer({ coordinates: { 99: 150, 100: 110, 101: 125, 102: 95, 103: 90 } });
+ // When the current depth display is rendered or resolved
view.render({
bids: depthLevels([[99, 80]]),
asks: depthLevels([[101, 70], [102, 100], [103, 90]]),
}, 100);
+ // Then keeps nearby labels apart and does not cover the current-price divider
assert.deepEqual(view.labels.map(({ text }) => text), ['102 · 100', '99 · 80']);
const boxes = view.rectangles.filter(({ height }) => height === 16);
assert.ok(boxes.every((box) => box.y + box.height < 110 || box.y > 110));
assert.ok(boxes[0].y + boxes[0].height < boxes[1].y);
});
-test('places bid and ask labels on opposite sides of a shared pixel row, including inverted scales', () => {
- for (const inverted of [false, true]) {
+for (const [scenarioIndex, inverted] of ([false, true]).entries()) {
+ test(`user places bid and ask labels on opposite sides of a shared pixel row, including inverted scales (case ${scenarioIndex + 1})`, () => {
+ // Given the native fixture represents this supported scenario
const coordinates = inverted ? { 99: 100.2, 101: 100.4 } : { 99: 100.4, 101: 100.2 };
const view = createLabelRenderer({ inverted, coordinates });
+ // When the real adapter handles this fixture
view.render({ bids: depthLevels([[99, 9]]), asks: depthLevels([[101, 10]]) });
+ // Then the user places bid and ask labels on opposite sides of a shared pixel row, including inverted scales
assert.deepEqual(view.labels.map(({ text }) => text), ['101 · 10', '99 · 9']);
assert.deepEqual(view.rectangles.filter(({ height }) => height === 16).map(({ y }) => y), inverted ? [102, 82] : [82, 102]);
- }
-});
+ });
+}
-test('omits labels that would overlap the collapse button or extend past the vertical canvas boundary', () => {
+test("user omits labels that would overlap the collapse button or extend past the vertical canvas boundary", () => {
+ // Given the chart geometry and visible depth levels are available
const view = createLabelRenderer({ coordinates: { 99: 220, 101: 38, 102: 10 } });
+ // When the current depth display is rendered or resolved
view.render({
bids: depthLevels([[99, 1_000]]),
asks: depthLevels([[101, 200], [102, 100]]),
});
+ // Then omits labels that would overlap the collapse button or extend past the vertical canvas boundary
assert.deepEqual(view.labels.map(({ text }) => text), ['99 · 1K']);
const narrow = createLabelRenderer({ width: 20, coordinates: { 101: 80 } });
@@ -586,9 +668,12 @@ test('omits labels that would overlap the collapse button or extend past the ver
assert.deepEqual(narrow.labels, []);
});
-test('repaints changed quantities and removes old labels when the depth canvas clears', () => {
+test("user repaints changed quantities and removes old labels when the depth canvas clears", () => {
+ // Given the chart geometry and visible depth levels are available
const view = createLabelRenderer({ coordinates: { 101: 80 } });
+ // When the current depth display is rendered or resolved
view.render({ bids: [], asks: depthLevels([[101, 3_800_000]]) });
+ // Then repaints changed quantities and removes old labels when the depth canvas clears
assert.deepEqual(view.labels.map(({ text }) => text), ['101 · 3.8M']);
view.render({ bids: [], asks: depthLevels([[101, 1_500_000]]) });
assert.deepEqual(view.labels.map(({ text }) => text), ['101 · 1.5M']);
@@ -597,13 +682,16 @@ test('repaints changed quantities and removes old labels when the depth canvas c
assert.deepEqual(view.rectangles, []);
});
-test('updates root geometry without rewriting unchanged styles', () => {
+test("user updates root geometry without rewriting unchanged styles", () => {
+ // Given the chart geometry and visible depth levels are available
const dom = createChartDom();
const { document } = dom.window;
const { host } = findDepthProfileHost(document);
const root = ensureDepthProfileView(document, host, { onToggle: () => {} });
+ // When the current depth display is rendered or resolved
setDepthProfileGeometry(root, { top: 4, height: 320, rightInset: 88 });
+ // Then updates root geometry without rewriting unchanged styles
assert.equal(root.style.top, '4px');
assert.equal(root.style.height, '320px');
assert.equal(root.style.right, '88px');
diff --git a/test/dom/binance-orderbook-trade/dialog-storage-boundaries.test.js b/test/dom/binance-orderbook-trade/dialog-storage-boundaries.test.js
new file mode 100644
index 0000000..dc443c1
--- /dev/null
+++ b/test/dom/binance-orderbook-trade/dialog-storage-boundaries.test.js
@@ -0,0 +1,253 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { loadFixtureDom, isVisibleElement } from '../../helpers/dom.js';
+import { showUsdtRebalanceDialog } from '../../../src/binance-orderbook-trade/dom/usdt-rebalance-dialog.js';
+import {
+ findNativeOrderbookPrecisionOverlay,
+ isNativeOrderbookPrecisionMenuOpen,
+} from '../../../src/binance-orderbook-trade/dom/orderbook-precision.js';
+import {
+ isModeSymbolOptionStorageKey,
+ loadModeSymbolPrecisionNumberOption,
+ loadSymbolSide,
+ migrateModeSymbolPrecisionNumberOption,
+ modeSymbolPrecisionOptionStorageKey,
+ saveModeSymbolPrecisionNumberOption,
+} from '../../../src/binance-orderbook-trade/core/panel-options.js';
+
+const DIALOG_ID = 'jh-binance-usdt-rebalance-dialog';
+const STYLE_ID = 'jh-binance-usdt-rebalance-dialog-style';
+const MODE_KEYS = { OPEN: 'open-ratio', CLOSE: 'close-ratio' };
+const RATIO_OPTIONS = [2, 10, 30];
+
+function openDocument(t, html = '') {
+ const dom = loadFixtureDom(html);
+ dom.reconfigure({ url: 'https://native-host.test/' });
+ t.after(() => dom.window.close());
+ return dom.window.document;
+}
+
+/** Native close changes the open state before delivering its later close event. */
+function openDialogHost(t) {
+ const document = openDocument(t);
+ const view = document.defaultView;
+ const calls = [];
+ view.HTMLDialogElement.prototype.showModal = function showModal() {
+ calls.push({ method: 'showModal', dialog: this });
+ this.open = true;
+ };
+ view.HTMLDialogElement.prototype.close = function close() {
+ calls.push({ method: 'close', dialog: this });
+ if (!this.open) return;
+ this.open = false;
+ view.queueMicrotask(() => this.dispatchEvent(new view.Event('close')));
+ };
+ return { document, calls };
+}
+
+function rebalanceModel() {
+ return {
+ title: 'Account Rebalance',
+ targetSummary: 'Move 5 USDT from Spot to Funding',
+ accountHeading: 'Account',
+ currentHeading: 'Current',
+ targetHeading: 'Target',
+ transferHeading: 'Transfer Plan',
+ question: 'Confirm one transfer?',
+ cancelLabel: 'Cancel',
+ confirmLabel: 'Confirm Rebalance',
+ balanceRows: [
+ { account: 'Funding', current: '10.00', target: '15.00' },
+ { account: 'Spot', current: '20.00', target: '15.00' },
+ ],
+ transferRows: [{ route: 'Spot → Funding', amount: '5.00 USDT' }],
+ };
+}
+
+test('user receives native dialog close state before the asynchronous close event', async t => {
+ // Given the dialog host has one mounted native dialog and a close-event observer.
+ const host = openDialogHost(t);
+ const dialog = host.document.createElement('dialog');
+ host.document.body.append(dialog);
+ const states = [];
+ dialog.addEventListener('close', () => states.push(dialog.open));
+ dialog.showModal();
+ assert.equal(dialog.open, true);
+
+ // When the native host closes the dialog twice before delivering events.
+ dialog.close();
+ dialog.close();
+
+ // Then open state changes synchronously and only one close event is queued.
+ assert.equal(dialog.open, false);
+ assert.deepEqual(states, []);
+ await Promise.resolve();
+ assert.deepEqual(states, [false]);
+ assert.deepEqual(host.calls.map(call => call.method), ['showModal', 'close', 'close']);
+ assert.equal(host.calls.every(call => call.dialog === dialog), true);
+});
+
+for (const variant of [
+ { name: 'an absent model', model: () => null, message: 'Invalid USDT rebalance dialog model' },
+ { name: 'non-array balance rows', model: () => ({ ...rebalanceModel(), balanceRows: {} }), message: 'Invalid USDT rebalance dialog model' },
+ { name: 'a blank title', model: () => ({ ...rebalanceModel(), title: ' ' }), message: 'Invalid USDT rebalance dialog title' },
+ { name: 'an absent balance account', model: () => ({ ...rebalanceModel(), balanceRows: [{ current: '10.00', target: '15.00' }] }), message: 'Invalid USDT rebalance dialog balance account' },
+ { name: 'a blank transfer route', model: () => ({ ...rebalanceModel(), transferRows: [{ route: ' ', amount: '5.00 USDT' }] }), message: 'Invalid USDT rebalance dialog transfer route' },
+ { name: 'an empty transfer plan', model: () => ({ ...rebalanceModel(), transferRows: [] }), message: 'USDT rebalance dialog requires at least one transfer' },
+]) {
+ test(`user cannot open a rebalance confirmation with ${variant.name}`, t => {
+ // Given the proposed dialog lacks one required public model contract.
+ const host = openDialogHost(t);
+ const model = variant.model();
+
+ // When the real dialog boundary receives the incomplete plan.
+ const open = () => showUsdtRebalanceDialog(host.document, model);
+
+ // Then it exposes the exact problem before installing style or opening a confirmation.
+ assert.throws(open, { message: variant.message });
+ assert.equal(host.document.getElementById(DIALOG_ID), null);
+ assert.equal(host.document.getElementById(STYLE_ID), null);
+ assert.deepEqual(host.calls, []);
+ });
+}
+
+test('user can reopen a rebalance dialog after native close without duplicate style or another close request', async t => {
+ // Given the first dialog mounts before the document head is available.
+ const host = openDialogHost(t);
+ host.document.head.remove();
+ const firstResult = showUsdtRebalanceDialog(host.document, rebalanceModel());
+ const first = host.document.getElementById(DIALOG_ID);
+ assert.equal(host.document.getElementById(STYLE_ID).parentElement, host.document.documentElement);
+
+ // When the native host closes the first dialog before its close event is processed.
+ first.close();
+ const cancelled = await firstResult;
+
+ // Then the public result is cancellation and cleanup does not close an already closed dialog again.
+ assert.equal(cancelled, false);
+ assert.equal(first.isConnected, false);
+ assert.deepEqual(host.calls.map(call => call.method), ['showModal', 'close']);
+
+ // When a second valid plan opens and its explicit confirmation button is clicked.
+ const secondResult = showUsdtRebalanceDialog(host.document, rebalanceModel());
+ const second = host.document.getElementById(DIALOG_ID);
+ assert.equal(host.document.activeElement.dataset.rebalanceDialogAction, 'cancel');
+ second.querySelector('[data-rebalance-dialog-action="confirm"]').click();
+ const confirmed = await secondResult;
+
+ // Then confirmation is distinct from native close and one stylesheet serves both dialog lifetimes.
+ assert.equal(confirmed, true);
+ assert.equal(second.isConnected, false);
+ assert.equal(host.document.querySelectorAll('#' + STYLE_ID).length, 1);
+ assert.deepEqual(host.calls.map(call => call.method), ['showModal', 'close', 'showModal', 'close']);
+});
+
+test('user ignores a native-looking precision trigger outside the actual futures orderbook', t => {
+ // Given another native control has the same precision classes outside the orderbook.
+ const document = openDocument(t, '
0.1
');
+ const trigger = document.querySelector('.tick-content');
+
+ // When both public precision readers inspect the unrelated native control.
+ const open = isNativeOrderbookPrecisionMenuOpen(trigger);
+ const overlay = findNativeOrderbookPrecisionOverlay(trigger, isVisibleElement);
+
+ // Then matching classes cannot turn an unrelated control into the orderbook menu.
+ assert.equal(open, false);
+ assert.equal(overlay, null);
+});
+
+test('user receives an explicit precision contract error when React moves the trigger out of its field', t => {
+ // Given the active native select has moved its tick text outside the verified trigger field.
+ const document = openDocument(t, '
0.1
');
+ const trigger = document.querySelector('.tick-content');
+
+ // When the public precision API resolves the changed native structure.
+ const read = () => isNativeOrderbookPrecisionMenuOpen(trigger);
+
+ // Then it rejects the new structure instead of clicking a guessed field.
+ assert.throws(read, { name: 'OrderbookPrecisionDomError', message: 'Native precision trigger structure has changed' });
+});
+
+test('user rejects a native precision overlay identity from a different control protocol', t => {
+ // Given the active native select publishes an overlay identifier outside its verified protocol.
+ const document = openDocument(t, '
0.1
');
+ const root = document.querySelector('.orderbook-tickSize');
+ const select = document.querySelector('.bn-select');
+ select.__reactFiber$native = {
+ memoizedProps: { overlay: { props: { id: 'unrelated-dialog-list' } } },
+ return: { stateNode: root },
+ };
+ const trigger = document.querySelector('.tick-content');
+
+ // When the real overlay resolver reads the host-provided owner chain.
+ const read = () => findNativeOrderbookPrecisionOverlay(trigger, isVisibleElement);
+
+ // Then the mismatched identifier is explicit before any overlay is accepted.
+ assert.throws(read, { name: 'OrderbookPrecisionDomError', message: 'Native precision listbox identity is invalid' });
+});
+
+test('user gets the default side and ratio from absent or unsupported native storage values', t => {
+ // Given a fresh native storage area contains an unsupported ratio for one symbol and precision.
+ const document = openDocument(t);
+ const storage = document.defaultView.localStorage;
+ const key = 'open-ratio:BTCUSDT:0.1';
+ storage.setItem(key, '999');
+
+ // When public settings readers load the new side and the unsupported persisted ratio.
+ const side = loadSymbolSide(storage, 'open-side', 'BTCUSDT');
+ const ratio = loadModeSymbolPrecisionNumberOption(storage, MODE_KEYS, 'OPEN', 'BTCUSDT', '0.1', RATIO_OPTIONS, 2);
+
+ // Then the designed defaults are returned without rewriting stored data or other scopes.
+ assert.equal(side, 'LONG');
+ assert.equal(ratio, 2);
+ assert.equal(storage.getItem(key), '999');
+ assert.equal(storage.length, 1);
+});
+
+test('user cannot migrate or save a ratio until its symbol and precision scope are known', t => {
+ // Given native storage already contains distinct open and close ratios.
+ const document = openDocument(t);
+ const storage = document.defaultView.localStorage;
+ storage.setItem('open-ratio:BTCUSDT:0.1', '10');
+ storage.setItem('close-ratio:BTCUSDT:0.1', '30');
+
+ // When migration lacks precision and a new save lacks its symbol.
+ const migrated = migrateModeSymbolPrecisionNumberOption(storage, MODE_KEYS, 'OPEN', 'BTCUSDT', '', 10, 30, RATIO_OPTIONS);
+ const saved = saveModeSymbolPrecisionNumberOption(storage, MODE_KEYS, 'OPEN', '', '0.1', 2, RATIO_OPTIONS);
+
+ // Then neither incomplete operation writes an unscoped setting or changes an existing mode.
+ assert.equal(migrated, false);
+ assert.equal(saved, false);
+ assert.equal(storage.length, 2);
+ assert.equal(storage.getItem('open-ratio:BTCUSDT:0.1'), '10');
+ assert.equal(storage.getItem('close-ratio:BTCUSDT:0.1'), '30');
+});
+
+test('user rejects a settings mode without its declared storage key', t => {
+ // Given an otherwise valid native storage scope omits the selected mode mapping.
+ const document = openDocument(t);
+ const storage = document.defaultView.localStorage;
+ const modeKeys = { CLOSE: MODE_KEYS.CLOSE };
+
+ // When the public scope builder and writer resolve the unavailable open-mode key.
+ const resolve = () => modeSymbolPrecisionOptionStorageKey(modeKeys, 'OPEN', 'BTCUSDT', '0.1');
+ const save = () => saveModeSymbolPrecisionNumberOption(storage, modeKeys, 'OPEN', 'BTCUSDT', '0.1', 2, RATIO_OPTIONS);
+
+ // Then both operations expose configuration failure and native storage remains empty.
+ assert.throws(resolve, { message: '交易模式缺少存储键：OPEN' });
+ assert.throws(save, { message: '交易模式缺少存储键：OPEN' });
+ assert.equal(storage.length, 0);
+});
+
+test('user does not treat a native storage-clear event as a symbol-specific ratio update', t => {
+ // Given the native storage event represents clearing storage rather than one changed key.
+ const document = openDocument(t);
+ const event = new document.defaultView.StorageEvent('storage', { key: null });
+
+ // When the public scope filter evaluates the native event identity.
+ const matches = isModeSymbolOptionStorageKey(event.key, Object.values(MODE_KEYS));
+
+ // Then no symbol or precision is invented from an absent key.
+ assert.equal(matches, false);
+ assert.equal(event.key, null);
+});
diff --git a/test/dom/binance-orderbook-trade/orderbook-precision.test.js b/test/dom/binance-orderbook-trade/orderbook-precision.test.js
index c1f2ee5..7869ef3 100644
--- a/test/dom/binance-orderbook-trade/orderbook-precision.test.js
+++ b/test/dom/binance-orderbook-trade/orderbook-precision.test.js
@@ -1,3 +1,4 @@
+import { captureThrownError } from '../../helpers/orderbook-migration-errors.js';
import test from 'node:test';
import assert from 'node:assert/strict';
import { readFileSync } from 'node:fs';
@@ -105,32 +106,43 @@ function installController(context, overrides = {}) {
]) vm.runInContext(declaration(name), context);
}
-test('reads exact native precision options from the control-owned body portal', () => {
+test("user reads exact native precision options from the control-owned body portal", () => {
+ // Given the native precision control and its menu state are available
const { document, root, context } = setup();
const trigger = root.querySelector('.tick-content');
const listbox = document.getElementById('bn-select-precision');
- assert.equal(root.contains(listbox), false);
+ // When the native precision selection is read or updated
+ const observed = root.contains(listbox);
+
+ // Then reads exact native precision options from the control-owned body portal
+ assert.equal(observed, false);
const nodes = context.getVisibleOrderbookPrecisionOptionNodes(trigger);
assert.deepEqual(Array.from(nodes, context.readOrderbookPrecisionOptionValue), [
'0.000001', '0.00001', '0.0001',
]);
});
-test('empty precision options have a visible status instead of four blank slots', () => {
+test("user sees that empty precision options have a visible status instead of four blank slots", () => {
+ // Given the native precision control and its menu state are available
const { document, context } = setup();
const row = document.createElement('div');
+ // When the native precision selection is read or updated
row.innerHTML = context.renderOrderbookPrecisionShortcutSlots([], '0.000001', null, false, 'Waiting for options').join('');
+ // Then sees that empty precision options have a visible status instead of four blank slots
assert.equal(row.textContent, 'Waiting for options');
assert.equal(row.querySelector('[role="status"]').getAttribute('data-orderbook-precision-status'), 'true');
assert.equal(row.querySelectorAll('[data-orderbook-precision-value]').length, 0);
});
-test('native options keep their exact values and reserve only the unused fourth slot', () => {
+test("user sees that native options keep their exact values and reserve only the unused fourth slot", () => {
+ // Given the native precision control and its menu state are available
const { document, context } = setup();
const row = document.createElement('div');
+ // When the native precision selection is read or updated
row.innerHTML = context.renderOrderbookPrecisionShortcutSlots(
['0.000001', '0.00001', '0.0001'], '0.000001', null, false, 'Waiting for options',
).join('');
+ // Then sees that native options keep their exact values and reserve only the unused fourth slot
assert.deepEqual(Array.from(row.querySelectorAll('button'), (node) => node.dataset.orderbookPrecisionValue), [
'0.000001', '0.00001', '0.0001',
]);
@@ -138,12 +150,15 @@ test('native options keep their exact values and reserve only the unused fourth
assert.equal(row.querySelector('[role="status"]'), null);
});
-test('a lookalike numeric portal cannot supply the precision menu options', () => {
+test("user sees that a lookalike numeric portal cannot supply the precision menu options", () => {
+ // Given the native precision control and its menu state are available
const { document, context } = setup();
const owned = document.getElementById('bn-select-precision');
const otherBubble = owned.closest('.bn-select-bubble').cloneNode(true);
otherBubble.querySelector('[role="listbox"]').id = 'bn-select-unrelated';
+ // When the native precision selection is read or updated
document.body.prepend(otherBubble);
+ // Then sees that a lookalike numeric portal cannot supply the precision menu options
assert.deepEqual(Array.from(context.getVisibleOrderbookPrecisionOptionNodes(), (node) => node.closest('[role="listbox"]').id), [
'bn-select-precision', 'bn-select-precision', 'bn-select-precision',
]);
@@ -151,52 +166,71 @@ test('a lookalike numeric portal cannot supply the precision menu options', () =
assert.deepEqual(Array.from(context.getVisibleOrderbookPrecisionOptionNodes()), []);
});
-test('closed, unmounted, or detached menus return no options', () => {
- for (const transition of ['closed', 'hidden', 'unmounted', 'detached']) {
+for (const [scenarioIndex, transition] of (['closed', 'hidden', 'unmounted', 'detached']).entries()) {
+ test(`user sees that closed, unmounted, or detached menus return no options (case ${scenarioIndex + 1})`, () => {
+ // Given the native fixture represents this supported scenario
const { root, document, context } = setup();
const trigger = root.querySelector('.tick-content');
if (transition === 'closed') root.querySelector('.bn-select').classList.remove('active');
if (transition === 'hidden') document.querySelector('.bn-select-bubble').setAttribute('data-hidden', '');
if (transition === 'unmounted') document.querySelector('.bn-select-bubble').remove();
if (transition === 'detached') root.remove();
- assert.equal(context.getVisibleOrderbookPrecisionOverlay(trigger), null, transition);
- }
-});
+ // When the real adapter handles this fixture
+ const observed = context.getVisibleOrderbookPrecisionOverlay(trigger);
-test('missing, ambiguous, escaped, or disagreeing React owners fail explicitly', () => {
- const mutations = [
+ // Then the user sees that closed, unmounted, or detached menus return no options
+ assert.equal(observed, null, transition);
+ });
+}
+
+{
+const mutations = [
(root) => { delete root.querySelector('.bn-select').__reactFiber$fixture; },
(_root, fiber) => { fiber.return.return = null; },
(_root, fiber) => { fiber.return.return = { memoizedProps: { overlay: { props: { id: 'bn-select-second' } } }, return: fiber.return.return }; },
(_root, fiber) => { fiber.alternate.return.memoizedProps.overlay.props.id = 'bn-select-replaced'; },
];
- for (const mutate of mutations) {
+for (const [scenarioIndex, mutate] of (mutations).entries()) {
+ test(`user sees that missing, ambiguous, escaped, or disagreeing React owners fail explicitly (case ${scenarioIndex + 1})`, () => {
+ // Given the native fixture represents this supported scenario
const { root, fiber, context } = setup();
mutate(root, fiber);
- assert.throws(() => context.getVisibleOrderbookPrecisionOverlay(), OrderbookPrecisionDomError);
+ // When the real adapter handles this fixture
+ const observedFailure = captureThrownError(() => context.getVisibleOrderbookPrecisionOverlay());
+
+ // Then the user sees that missing, ambiguous, escaped, or disagreeing React owners fail explicitly
+ assert.ok(observedFailure instanceof OrderbookPrecisionDomError);
assert.equal(context.readCurrentOrderbookPrecisionValue(), '0.000001');
- }
-});
+ });
+}
+}
-test('the current native root is reacquired after a same-symbol replacement', () => {
+test("user sees that the current native root is reacquired after a same-symbol replacement", () => {
+ // Given the native precision control and its menu state are available
const { document, root, context } = setup();
const oldTrigger = root.querySelector('.tick-content');
const replacement = root.cloneNode(true);
root.replaceWith(replacement);
attachDropdownOwner(replacement, 'bn-select-new');
const listbox = document.getElementById('bn-select-precision');
+ // When the native precision selection is read or updated
listbox.id = 'bn-select-new';
+ // Then sees that the current native root is reacquired after a same-symbol replacement
assert.equal(context.getVisibleOrderbookPrecisionOverlay(oldTrigger), null);
assert.equal(context.getVisibleOrderbookPrecisionOverlay(), listbox.parentElement);
});
-test('an owner-linked element with a changed listbox contract fails explicitly', () => {
+test("user sees that an owner-linked element with a changed listbox contract fails explicitly", () => {
+ // Given the native precision control and its menu state are available
const { document, context } = setup();
+ // When the native precision selection is read or updated
document.getElementById('bn-select-precision').setAttribute('role', 'menu');
+ // Then sees that an owner-linked element with a changed listbox contract fails explicitly
assert.throws(() => context.getVisibleOrderbookPrecisionOverlay(), /listbox structure has changed/);
});
-test('cleanup closes only the captured trigger without selecting an option', async () => {
+test("user sees that cleanup closes only the captured trigger without selecting an option", async () => {
+ // Given the native precision control and its menu state are available
const { root, context } = setup();
const trigger = root.querySelector('.tick-content');
const clicks = [];
@@ -207,29 +241,39 @@ test('cleanup closes only the captured trigger without selecting an option', asy
return true;
},
});
+ // When the native precision selection is read or updated
delete root.querySelector('.bn-select').__reactFiber$fixture;
+ // Then sees that cleanup closes only the captured trigger without selecting an option
assert.equal(await context.closeOrderbookPrecisionOptions(trigger), true);
assert.deepEqual(clicks, [root.querySelector('.bn-select-trigger')]);
assert.equal(trigger.textContent.trim(), '0.000001');
});
-test('cleanup never clicks a replacement trigger or a user-closed menu', async () => {
- for (const transition of ['replaced', 'closed']) {
+for (const [scenarioIndex, transition] of (['replaced', 'closed']).entries()) {
+ test(`user sees that cleanup never clicks a replacement trigger or a user-closed menu (case ${scenarioIndex + 1})`, async () => {
+ // Given the native fixture represents this supported scenario
const { root, context } = setup();
const trigger = root.querySelector('.tick-content');
let clicks = 0;
installController(context, { clickDomTarget() { clicks += 1; return true; } });
if (transition === 'replaced') root.replaceWith(root.cloneNode(true));
else root.querySelector('.bn-select').classList.remove('active');
- assert.equal(await context.closeOrderbookPrecisionOptions(trigger), true);
+ // When the real adapter handles this fixture
+ const observed = await context.closeOrderbookPrecisionOptions(trigger);
+
+ // Then the user sees that cleanup never clicks a replacement trigger or a user-closed menu
+ assert.equal(observed, true);
assert.equal(clicks, 0, transition);
- }
-});
+ });
+}
-test('precision jobs expose DOM contract failures and discard cached options', async () => {
+test("user sees that precision jobs expose DOM contract failures and discard cached options", async () => {
+ // Given the native precision control and its menu state are available
const { context } = setup();
+ // When the native precision selection is read or updated
installController(context);
const error = new OrderbookPrecisionDomError('Native precision listbox identity changed between renders');
+ // Then sees that precision jobs expose DOM contract failures and discard cached options
assert.equal(await context.runOrderbookPrecisionSelectionTask(async () => { throw error; }), false);
assert.deepEqual(Array.from(context.orderbookPrecisionState.nativeOptions), []);
assert.equal(context.orderbookPrecisionState.nativeOptionsStatus, error.message);
@@ -238,9 +282,11 @@ test('precision jobs expose DOM contract failures and discard cached options', a
await assert.rejects(context.runOrderbookPrecisionSelectionTask(async () => { throw unexpected; }), unexpected);
});
-test('a failed precision job cannot overwrite the next symbol state', async () => {
+test("user sees that a failed precision job cannot overwrite the next symbol state", async () => {
+ // Given the native precision control and its menu state are available
const { context } = setup();
let symbol = 'SOPHUSDT';
+ // When the native precision selection is read or updated
installController(context, {
getCurrentSymbol: () => symbol,
isCurrentObservedSymbol: (captured) => captured === symbol,
@@ -252,12 +298,14 @@ test('a failed precision job cannot overwrite the next symbol state', async () =
context.orderbookPrecisionState = nextState;
throw new OrderbookPrecisionDomError('Native precision React ownership is unavailable');
});
+ // Then sees that a failed precision job cannot overwrite the next symbol state
assert.equal(result, false);
assert.equal(context.orderbookPrecisionState, nextState);
assert.equal(context.orderbookPrecisionSelectionTask, null);
});
-test('observer contract failures preserve current-precision invalidation and visible error state', () => {
+test("user sees that observer contract failures preserve current-precision invalidation and visible error state", () => {
+ // Given the native precision control and its menu state are available
const { root, context } = setup();
let callback;
let stoppedEdits = 0;
@@ -272,7 +320,9 @@ test('observer contract failures preserve current-precision invalidation and vis
context.ensureOrderbookPrecisionObserver();
root.querySelector('.tick-content span').textContent = '0.00001';
delete root.querySelector('.bn-select').__reactFiber$fixture;
+ // When the native precision selection is read or updated
callback();
+ // Then sees that observer contract failures preserve current-precision invalidation and visible error state
assert.equal(context.lastObservedOrderbookPrecision, '0.00001');
assert.equal(stoppedEdits, 1);
assert.equal(context.ladderPanelBodySignature, '');
@@ -282,12 +332,14 @@ test('observer contract failures preserve current-precision invalidation and vis
assert.throws(callback, /Unexpected programmer error/);
});
-test('bootstrap discards a snapshot replaced during cleanup before committing new options', async () => {
+test("user sees that bootstrap discards a snapshot replaced during cleanup before committing new options", async () => {
+ // Given the native precision control and its menu state are available
const { document, root, context } = setup();
let menuOpen = false;
let closes = 0;
let currentOptions = ['0.000001', '0.00001', '0.0001'];
installController(context);
+ // When the native precision selection is read or updated
Object.assign(context, {
waitForOrderbookPrecisionBootstrapReady: async () => context.findOrderbookPrecisionTrigger(),
getVisibleOrderbookPrecisionOptionNodes: () => menuOpen ? currentOptions : [],
@@ -307,6 +359,7 @@ test('bootstrap discards a snapshot replaced during cleanup before committing ne
return true;
},
});
+ // Then sees that bootstrap discards a snapshot replaced during cleanup before committing new options
assert.equal(await context.runLoadOrderbookPrecisionOptions(), true);
assert.equal(closes, 2);
assert.equal(root.isConnected, false);
@@ -315,10 +368,12 @@ test('bootstrap discards a snapshot replaced during cleanup before committing ne
assert.equal(context.orderbookPrecisionState.current, '0.001');
});
-test('bootstrap preserves an already open native precision menu', async () => {
+test("user sees that bootstrap preserves an already open native precision menu", async () => {
+ // Given the native precision control and its menu state are available
const { context } = setup();
installController(context);
let closes = 0;
+ // When the native precision selection is read or updated
Object.assign(context, {
waitForOrderbookPrecisionBootstrapReady: async () => context.findOrderbookPrecisionTrigger(),
getVisibleOrderbookPrecisionOptionNodes: () => ['option'],
@@ -326,16 +381,19 @@ test('bootstrap preserves an already open native precision menu', async () => {
readVisibleOrderbookPrecisionOptionValues: () => ['0.000001', '0.00001'],
closeOrderbookPrecisionOptions: async () => { closes += 1; return true; },
});
+ // Then sees that bootstrap preserves an already open native precision menu
assert.equal(await context.runLoadOrderbookPrecisionOptions(), true);
assert.equal(closes, 0);
assert.deepEqual(Array.from(context.orderbookPrecisionState.nativeOptions), ['0.000001', '0.00001']);
});
-test('bootstrap reacquires the displayed precision after it changes during cleanup', async () => {
+test("user sees that bootstrap reacquires the displayed precision after it changes during cleanup", async () => {
+ // Given the native precision control and its menu state are available
const { root, context } = setup();
installController(context);
let closes = 0;
const values = ['0.000001', '0.00001', '0.0001'];
+ // When the native precision selection is read or updated
Object.assign(context, {
waitForOrderbookPrecisionBootstrapReady: async () => context.findOrderbookPrecisionTrigger(),
getVisibleOrderbookPrecisionOptionNodes: () => [],
@@ -348,13 +406,15 @@ test('bootstrap reacquires the displayed precision after it changes during clean
return true;
},
});
+ // Then sees that bootstrap reacquires the displayed precision after it changes during cleanup
assert.equal(await context.runLoadOrderbookPrecisionOptions(), true);
assert.equal(closes, 2);
assert.equal(context.orderbookPrecisionState.current, '0.00001');
assert.deepEqual(Array.from(context.orderbookPrecisionState.nativeOptions), values);
});
-test('bootstrap discards its snapshot when the symbol changes during cleanup', async () => {
+test("user sees that bootstrap discards its snapshot when the symbol changes during cleanup", async () => {
+ // Given the native precision control and its menu state are available
const { context } = setup();
let symbol = 'SOPHUSDT';
installController(context, {
@@ -362,6 +422,7 @@ test('bootstrap discards its snapshot when the symbol changes during cleanup', a
isCurrentObservedSymbol: (captured) => captured === symbol,
});
const nextState = { symbol: 'BTCUSDT', nativeOptions: ['0.1', '1'], nativeOptionsStatus: null };
+ // When the native precision selection is read or updated
Object.assign(context, {
waitForOrderbookPrecisionBootstrapReady: async () => context.findOrderbookPrecisionTrigger(),
getVisibleOrderbookPrecisionOptionNodes: () => [],
@@ -374,6 +435,7 @@ test('bootstrap discards its snapshot when the symbol changes during cleanup', a
return true;
},
});
+ // Then sees that bootstrap discards its snapshot when the symbol changes during cleanup
assert.equal(await context.runLoadOrderbookPrecisionOptions(), false);
assert.equal(context.orderbookPrecisionState, nextState);
});
diff --git a/test/dom/binance-orderbook-trade/remaining-dom-boundaries.test.js b/test/dom/binance-orderbook-trade/remaining-dom-boundaries.test.js
new file mode 100644
index 0000000..3289e96
--- /dev/null
+++ b/test/dom/binance-orderbook-trade/remaining-dom-boundaries.test.js
@@ -0,0 +1,481 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { loadFixtureDom, isVisibleElement } from '../../helpers/dom.js';
+import {
+ clearDepthProfile,
+ ensureDepthProfileView,
+ findDepthProfileHost,
+ getTradingViewDepthProfileGeometry,
+ renderDepthProfile,
+} from '../../../src/binance-orderbook-trade/dom/depth-profile.js';
+import {
+ createBoundedInputWriter,
+ createTradeInputResolver,
+ createTradeInputStateReader,
+ findActiveTradeInputs,
+ isScriptOwnedTradeInputRecoveryState,
+ mutationTouchesCloseQuantity,
+} from '../../../src/binance-orderbook-trade/dom/trade-form.js';
+import {
+ compareDecimalStrings,
+ normalizeDecimalString,
+} from '../../../src/binance-orderbook-trade/core/decimal.js';
+
+function openChart(t) {
+ const dom = loadFixtureDom('
';
+
+function openForm(t) {
+ const dom = loadFixtureDom(formHtml);
+ t.after(() => dom.window.close());
+ const { document } = dom.window;
+ const writes = [];
+ document.addEventListener('input', event => writes.push({ id: event.target.id, value: event.target.value }));
+ const resolveInputs = createTradeInputResolver(document, { panelId: 'own-panel', isVisibleElement });
+ const writeValue = (input, value) => {
+ input.value = value;
+ input.dispatchEvent(new dom.window.Event('input', { bubbles: true }));
+ };
+ return { document, resolveInputs, writes, writeValue };
+}
+
+function readerOptions(host, extra = {}) {
+ return {
+ resolveInputs: host.resolveInputs,
+ expectedPrice: '10',
+ expectedQty: '0.2',
+ includePrice: false,
+ normalizeValue: normalizeDecimalString,
+ compareValues: compareDecimalStrings,
+ writeValue: host.writeValue,
+ ...extra,
+ };
+}
+
+test('user receives the declared native geometry and canvas recording contract', t => {
+ // Given the host exposes a native pane, price axis, and available two-dimensional canvas.
+ const host = openProfile(t);
+
+ // When native API consumers read geometry and issue drawing commands.
+ const chart = host.frame.contentWindow.tradingViewApi.activeChart();
+ const context = host.canvas.getContext('2d');
+ context.setTransform(2, 0, 0, 2, 0, 0);
+ context.fillRect(1, 2, 3, 4);
+ context.fillText('Order', 8, 9);
+
+ // Then the boundary preserves exact API values and records only the requested operations.
+ assert.equal(chart, host.chart);
+ assert.deepEqual(chart.getAllPanesHeight(), [200]);
+ assert.equal(chart.getPanes()[0].getMainSourcePriceScale(), host.scale);
+ assert.equal(host.scale.coordinateToPrice(0), 20);
+ assert.equal(host.scale.coordinateToPrice(200), 0);
+ assert.deepEqual(host.axis.getBoundingClientRect(), {
+ top: 0, left: 912, right: 1000, bottom: 200, width: 88, height: 200,
+ });
+ assert.equal(host.canvas.getContext('2d'), context);
+ assert.deepEqual(context.measureText('Order'), { width: 30 });
+ assert.deepEqual(host.calls, [
+ { method: 'setTransform', args: [2, 0, 0, 2, 0, 0] },
+ { method: 'fillRect', args: [1, 2, 3, 4] },
+ { method: 'fillText', args: ['Order', 8, 9] },
+ ]);
+ host.state.available = false;
+ assert.equal(host.canvas.getContext('2d'), null);
+});
+
+test('user cannot mount a depth profile on two visible native frames', t => {
+ // Given one chart root contains two visible embedded chart frames.
+ const { document, frame } = openChart(t);
+ frame.parentElement.append(frame.cloneNode());
+
+ // When the actual host resolver selects the native chart.
+ const resolve = () => findDepthProfileHost(document);
+
+ // Then ambiguity is explicit and no profile is installed.
+ assert.throws(resolve, { message: 'Visible chart frame count is invalid: 2' });
+ assert.equal(document.getElementById('jh-binance-depth-profile'), null);
+});
+
+for (const variant of [
+ { name: 'unpublished pane heights', configure: host => { host.state.heights = null; } },
+ { name: 'an empty pane collection', configure: host => { host.state.panes = []; } },
+ { name: 'a zero-height main pane', configure: host => { host.state.heights = [0]; } },
+ { name: 'an incomplete price-scale API', configure: host => { host.scale.getMode = null; } },
+ { name: 'a zero-width native viewport', configure: host => { host.state.viewportWidth = 0; } },
+ { name: 'an unbounded native price axis', configure: host => { host.state.axisWidth = Infinity; } },
+ { name: 'an unpublished visible price range', configure: host => { host.state.range = null; } },
+ { name: 'a constant native price scale', configure: host => { host.state.convert = () => 10; } },
+]) {
+ test(`user declines depth geometry with ${variant.name}`, t => {
+ // Given the current native chart is incomplete in one explicit host contract.
+ const host = openChart(t);
+ variant.configure(host);
+
+ // When the real adapter asks for a price-coordinate mapping.
+ const geometry = getTradingViewDepthProfileGeometry(host.frame);
+
+ // Then no fabricated scale or overlay is supplied.
+ assert.equal(geometry, null);
+ assert.equal(host.document.getElementById('jh-binance-depth-profile'), null);
+ });
+}
+
+test('user maps both exact visible price boundaries to the native pane edges', t => {
+ // Given a verified native scale covers prices zero through twenty.
+ const { frame } = openChart(t);
+
+ // When the adapter resolves both endpoints and an out-of-range price.
+ const geometry = getTradingViewDepthProfileGeometry(frame);
+
+ // Then endpoints retain their exact native coordinates without interpolation drift.
+ assert.equal(geometry.priceToCoordinate(20), 0);
+ assert.equal(geometry.priceToCoordinate(0), 200);
+ assert.equal(geometry.priceToCoordinate(-1), null);
+});
+
+test('user remounts the depth view with one stylesheet even before a document head exists', t => {
+ // Given a valid host exists before head mounting, and invalid public arguments are rejected.
+ const { document } = openChart(t);
+ document.head.remove();
+ const parent = document.querySelector('section');
+ assert.throws(() => ensureDepthProfileView(document, null, { onToggle: () => true }), { message: 'Invalid depth profile host' });
+ assert.throws(() => ensureDepthProfileView(document, parent, { onToggle: null }), { message: 'Invalid depth profile toggle listener' });
+ let toggles = 0;
+ const original = ensureDepthProfileView(document, parent, { onToggle: () => { toggles += 1; } });
+ const nextHost = document.createElement('section');
+ document.body.append(nextHost);
+
+ // When a replacement native host receives the profile and its real toggle is clicked.
+ const current = ensureDepthProfileView(document, nextHost, { onToggle: () => { toggles += 1; } });
+ current.querySelector('[data-depth-profile-toggle]').click();
+
+ // Then the stale view is removed and a single root stylesheet and new toggle remain.
+ assert.equal(original.isConnected, false);
+ assert.equal(current.parentElement, nextHost);
+ assert.equal(document.querySelectorAll('#jh-binance-depth-profile-style').length, 1);
+ assert.equal(document.getElementById('jh-binance-depth-profile-style').parentElement, document.documentElement);
+ assert.equal(toggles, 1);
+});
+
+test('user clears an empty depth book at one device pixel without drawing invented liquidity', t => {
+ // Given the current native book is empty and the browser does not supply a device scale.
+ const host = openProfile(t);
+ Object.defineProperty(host.document.defaultView, 'devicePixelRatio', { configurable: true, value: 0 });
+ const geometry = getTradingViewDepthProfileGeometry(host.frame);
+
+ // When the real renderer receives no bid or ask levels and no visible latest trade.
+ const rendered = renderDepthProfile(host.root, { bids: [], asks: [] }, geometry, 21);
+
+ // Then the canvas is sized and cleared once without bars, labels, or a divider.
+ assert.equal(rendered, true);
+ assert.equal(host.canvas.width, 132);
+ assert.equal(host.canvas.height, 200);
+ assert.deepEqual(host.calls, [
+ { method: 'setTransform', args: [1, 0, 0, 1, 0, 0] },
+ { method: 'clearRect', args: [0, 0, 132, 200] },
+ ]);
+});
+
+test('user receives no depth paint for an invisible canvas and explicit failure for a missing context', t => {
+ // Given the profile canvas has no visible width.
+ const host = openProfile(t);
+ const geometry = getTradingViewDepthProfileGeometry(host.frame);
+ host.state.width = 0;
+
+ // When the renderer handles the invisible canvas.
+ const rendered = renderDepthProfile(host.root, { bids: [], asks: [] }, geometry, 10);
+
+ // Then it leaves the drawing context untouched.
+ assert.equal(rendered, false);
+ assert.deepEqual(host.calls, []);
+
+ // When the canvas becomes visible but its native two-dimensional context is unavailable.
+ host.state.width = 132;
+ host.state.available = false;
+
+ // Then both render and clear expose the missing host dependency.
+ assert.throws(() => renderDepthProfile(host.root, { bids: [], asks: [] }, geometry, 10), { message: 'Depth profile canvas context is unavailable' });
+ assert.throws(() => clearDepthProfile(host.root), { message: 'Depth profile canvas context is unavailable' });
+ assert.deepEqual(host.calls, []);
+});
+
+test('user keeps the largest cumulative bar while adding every quantity in the same pixel row', t => {
+ // Given two bid prices share a pixel, with the smaller cumulative value arriving second.
+ const host = openProfile(t);
+ const geometry = getTradingViewDepthProfileGeometry(host.frame);
+ const profile = {
+ asks: [{ price: 14, quantity: 10, cumulative: 10 }],
+ bids: [{ price: 11, quantity: 2, cumulative: 5 }, { price: 11.02, quantity: 1, cumulative: 3 }],
+ };
+
+ // When the production renderer buckets the exact visible levels.
+ renderDepthProfile(host.root, profile, geometry, 21);
+
+ // Then the bid retains width sixty-six and its band label includes all three units.
+ assert.deepEqual(host.calls.filter(call => call.method === 'fillRect' && call.args[3] === 1).map(call => call.args), [
+ [0, 60, 132, 1],
+ [66, 90, 66, 1],
+ ]);
+ assert.deepEqual(host.calls.filter(call => call.method === 'fillText').map(call => call.args[0]), ['14 · 10', '11–11.02 · 3']);
+});
+
+for (const showStatus of [false, true]) {
+ test(`user orders equal depth labels by price with status visibility ${showStatus}`, t => {
+ // Given equal-quantity bid labels compete near the native status control.
+ const host = openProfile(t);
+ const geometry = getTradingViewDepthProfileGeometry(host.frame);
+ host.root.querySelector('.jh-depth-profile-status').textContent = showStatus ? 'Synchronizing' : '';
+ const profile = {
+ asks: [],
+ bids: [{ price: 12, quantity: 3, cumulative: 3 }, { price: 8, quantity: 3, cumulative: 6 }],
+ };
+
+ // When the real label placement accounts for equal quantities and visible controls.
+ renderDepthProfile(host.root, profile, geometry, 21);
+
+ // Then price breaks the tie and an active status box excludes only its overlapping label.
+ assert.deepEqual(host.calls.filter(call => call.method === 'fillText').map(call => call.args[0]),
+ showStatus ? ['12 · 3'] : ['8 · 3', '12 · 3']);
+ });
+}
+
+test('user keeps a visible cumulative depth bar when its individual quantity is too small for a label', t => {
+ // Given one visible price has a small quantity within a much larger cumulative depth.
+ const host = openProfile(t);
+ const geometry = getTradingViewDepthProfileGeometry(host.frame);
+
+ // When the renderer evaluates label density for that price.
+ renderDepthProfile(host.root, { asks: [], bids: [{ price: 11, quantity: 1, cumulative: 1000 }] }, geometry, 21);
+
+ // Then the exact bar remains while no unreadable label is painted.
+ assert.deepEqual(host.calls.filter(call => call.method === 'fillRect').map(call => call.args), [[0, 90, 132, 1]]);
+ assert.deepEqual(host.calls.filter(call => call.method === 'fillText'), []);
+});
+
+test('user recognizes a native quantity text mutation and discards its detached stale record', t => {
+ // Given a real observer watches the native quantity text node.
+ const { document } = openForm(t);
+ const quantity = document.createElement('div');
+ quantity.dataset.testid = 'max-sell-amount';
+ quantity.textContent = '可平 1 HYPE';
+ document.querySelector('#native-form').append(quantity);
+ const observer = new document.defaultView.MutationObserver(records => records.length);
+ observer.observe(quantity, { characterData: true, subtree: true });
+
+ // When the native renderer updates the same text node.
+ const text = quantity.firstChild;
+ text.data = '可平 2 HYPE';
+ const records = observer.takeRecords();
+
+ // Then the real character-data record is quantity evidence.
+ assert.equal(records.length, 1);
+ assert.equal(records[0].type, 'characterData');
+ assert.equal(mutationTouchesCloseQuantity(records[0]), true);
+
+ // When that observed text is detached before a stale consumer reuses the record.
+ text.remove();
+ observer.disconnect();
+
+ // Then stale or absent evidence cannot confirm a new close snapshot.
+ assert.equal(mutationTouchesCloseQuantity(records[0]), false);
+ assert.equal(mutationTouchesCloseQuantity(null), false);
+});
+
+test('user waits for a coherent replacement form after the previous owner disconnects', t => {
+ // Given the resolver already owns one complete native form.
+ const host = openForm(t);
+ const initial = host.resolveInputs();
+ assert.equal(initial.root.id, 'native-form');
+ initial.root.remove();
+ host.document.body.innerHTML = '
开仓
';
+
+ // When the old owner has disconnected but the new tab and input have no common form owner.
+ const unresolved = host.resolveInputs();
+ const readState = createTradeInputStateReader(readerOptions(host));
+
+ // Then neither discovery nor synchronization uses unrelated document nodes.
+ assert.equal(unresolved, null);
+ assert.equal(findActiveTradeInputs(host.document, { panelId: 'own-panel', isVisibleElement }), null);
+ assert.equal(readState(), null);
+ assert.deepEqual(host.writes, []);
+
+ // When the native renderer finishes mounting a coherent form.
+ host.document.body.innerHTML = formHtml;
+ const current = host.resolveInputs();
+
+ // Then fresh ownership resolves both inputs without reviving the detached node.
+ assert.equal(current.root.id, 'native-form');
+ assert.notEqual(current.root, initial.root);
+ assert.equal(current.qtyInput.id, 'unitAmount-open');
+ assert.equal(current.priceInput.id, 'limitPrice-open');
+});
+
+test('user preserves a native input when its writer budget is exhausted and resumes on a replacement node', t => {
+ // Given the existing input has consumed its one allowed native write.
+ const host = openForm(t);
+ const writer = createBoundedInputWriter({ writeValue: host.writeValue, maxWriteAttempts: 1 });
+ const original = host.resolveInputs().qtyInput;
+ assert.equal(writer(original, '0.15'), true);
+ const readState = createTradeInputStateReader(readerOptions(host, { writeValue: writer }));
+
+ // When synchronization requests another value from that exhausted native node.
+ const first = readState();
+ const second = readState();
+
+ // Then refusal does not trigger another write or pretend that the expected quantity is ready.
+ assert.equal(first, null);
+ assert.equal(second, null);
+ assert.equal(original.value, '0.15');
+ assert.deepEqual(host.writes, [{ id: 'unitAmount-open', value: '0.15' }]);
+
+ // When React replaces the input with a new node carrying its own write budget.
+ const replacement = original.cloneNode();
+ original.replaceWith(replacement);
+ assert.equal(readState(), null);
+ const synchronized = readState();
+
+ // Then the fresh node receives exactly one requested write and becomes the submission target.
+ assert.equal(synchronized.qtyInput, replacement);
+ assert.equal(synchronized.submittedQty, '0.2');
+ assert.deepEqual(host.writes, [
+ { id: 'unitAmount-open', value: '0.15' },
+ { id: 'unitAmount-open', value: '0.2' },
+ ]);
+});
+
+test('user keeps a manual quantity edit after the final permitted synchronized write', t => {
+ // Given one script write has reached an acknowledged stable quantity.
+ const host = openForm(t);
+ const readState = createTradeInputStateReader(readerOptions(host, { maxWriteAttempts: 1 }));
+ assert.equal(readState(), null);
+ assert.equal(readState().submittedQty, '0.2');
+
+ // When a real native input event publishes a later manual edit.
+ host.writeValue(host.resolveInputs().qtyInput, '0.3');
+ const afterEdit = readState();
+ const afterAnotherRead = readState();
+
+ // Then the exhausted recovery budget preserves the manual value and leaves submission unready.
+ assert.equal(afterEdit, null);
+ assert.equal(afterAnotherRead, null);
+ assert.equal(host.resolveInputs().qtyInput.value, '0.3');
+ assert.deepEqual(host.writes, [
+ { id: 'unitAmount-open', value: '0.2' },
+ { id: 'unitAmount-open', value: '0.3' },
+ ]);
+});
+
+test('user rejects incomplete synchronization dependencies before any native input is written', t => {
+ // Given a complete native form has not received any input operation.
+ const host = openForm(t);
+
+ // When public synchronization helpers receive missing dependencies or invalid budgets.
+ const calls = [
+ [() => createBoundedInputWriter({ writeValue: null, maxWriteAttempts: 1 }), '输入框写入依赖异常'],
+ [() => createBoundedInputWriter({ writeValue: host.writeValue, maxWriteAttempts: 0 }), '输入框写入次数必须为正整数'],
+ [() => isScriptOwnedTradeInputRecoveryState({ compareValues: null }), '输入框恢复校验依赖异常'],
+ [() => createTradeInputStateReader(readerOptions(host, { readNowMs: null })), '交易输入框同步依赖异常'],
+ ];
+
+ // Then each invalid contract is explicit and the native price and quantity remain untouched.
+ for (const [call, message] of calls) assert.throws(call, { message });
+ assert.equal(host.resolveInputs().qtyInput.value, '0.1');
+ assert.equal(host.resolveInputs().priceInput.value, '10');
+ assert.deepEqual(host.writes, []);
+});
+
+for (const variant of [
+ { name: 'three empty native states', values: [null, null, null], previous: undefined, allowed: true },
+ { name: 'the previously acknowledged quantity', values: ['0.20', '0.2', '0.200'], previous: '0.2', allowed: true },
+ { name: 'a manual value without an acknowledged predecessor', values: ['0.3', null, null], previous: undefined, allowed: false },
+ { name: 'a manual edit after an acknowledged predecessor', values: [null, '0.2', '0.3'], previous: '0.2', allowed: false },
+]) {
+ test(`user allows recovery only for owned inputs with ${variant.name}`, () => {
+ // Given the host exposes explicit pre-write, rollback, and current quantities.
+ const [preWriteValue, rollbackValue, submittedValue] = variant.values;
+
+ // When the real ownership contract compares the current state with its acknowledged predecessor.
+ const allowed = isScriptOwnedTradeInputRecoveryState({
+ preWriteValue, rollbackValue, submittedValue,
+ previousSubmittedValue: variant.previous, compareValues: compareDecimalStrings,
+ });
+
+ // Then manual values cannot be mistaken for script-owned rollback state.
+ assert.equal(allowed, variant.allowed);
+ });
+}
diff --git a/test/dom/binance-orderbook-trade/trade-form-boundaries.test.js b/test/dom/binance-orderbook-trade/trade-form-boundaries.test.js
new file mode 100644
index 0000000..38a0eb4
--- /dev/null
+++ b/test/dom/binance-orderbook-trade/trade-form-boundaries.test.js
@@ -0,0 +1,259 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { loadFixtureDom, isVisibleElement } from '../../helpers/dom.js';
+import { captureThrownError } from '../../helpers/orderbook-migration-errors.js';
+import { createAnimationFrameBoundary } from '../../helpers/orderbook-migration-frames.js';
+import {
+ calculateFloatingPanelLayout,
+ collectTradeButtonsFromScopes,
+ createTradeInputResolver,
+ findActiveTradeInputs,
+ findCurrentLeverageButtonFromScopes,
+ findTradeFormRoot,
+ findTradePanelInsertionPoint,
+ isTradeActionButton,
+ isTradeModeTab,
+ parseLeverageButtonText,
+ placeTradePanelSpacer,
+ readTradeAvailableBalance,
+ waitForTradeActionButtonFrameState,
+ waitForTradeFormFrameState,
+ waitForTradeFormMutationState,
+} from '../../../src/binance-orderbook-trade/dom/trade-form.js';
+
+const fixture = await readFile(new URL('../../fixtures/binance-orderbook-trade/right-trade-form.html', import.meta.url), 'utf8');
+const panelId = 'jh-binance-close-qty-multiplier-panel';
+
+for (const { label, html } of [
+ { label: 'multiple value siblings', html: '
Avbl1 USDT2 USDT
' },
+ { label: 'missing value', html: '
Avbl
' },
+ { label: 'empty value', html: '
Avbl
' },
+ { label: 'malformed value', html: '
Avblpending
' },
+ { label: 'hidden label', html: '
Avbl1 USDT
' },
+ { label: 'hidden value', html: '
Avbl1 USDT
' },
+]) {
+ test(`user cannot infer available balance from ${label}`, () => {
+ // Given the current trade form lacks one unique visible balance value
+ const { window } = loadFixtureDom(`${html}`);
+
+ // When the balance adapter reads the actual native DOM
+ const balance = readTradeAvailableBalance(window.document.querySelector('section'), { isVisibleElement });
+
+ // Then incomplete or hidden balance evidence remains unresolved
+ assert.equal(balance, null);
+ });
+}
+
+test('user leaves trade discovery unavailable when its DOM dependencies are missing', () => {
+ // Given the native form exists but one required discovery dependency is unavailable
+ const { window } = loadFixtureDom(fixture);
+
+ // When public adapters receive an absent root or visibility predicate
+ const missingBalanceRoot = readTradeAvailableBalance(null, { isVisibleElement });
+ const missingBalanceVisibility = readTradeAvailableBalance(window.document, { isVisibleElement: null });
+ const missingInputsRoot = findActiveTradeInputs(null, { panelId, isVisibleElement });
+ const missingInputsVisibility = findActiveTradeInputs(window.document, { panelId, isVisibleElement: null });
+ const resolverError = captureThrownError(() => createTradeInputResolver(null, { panelId, isVisibleElement }));
+
+ // Then readers return no inferred inputs and resolver construction exposes its invalid dependency
+ assert.equal(missingBalanceRoot, null);
+ assert.equal(missingBalanceVisibility, null);
+ assert.equal(missingInputsRoot, null);
+ assert.equal(missingInputsVisibility, null);
+ assert.equal(resolverError.message, '交易表单解析依赖异常');
+});
+
+test('user rejects detached, cross-document, and unrelated trade field pairs', () => {
+ // Given two documents and disconnected nodes cannot share one coherent native form owner
+ const { window } = loadFixtureDom('
Open
');
+ const second = loadFixtureDom('');
+ const tab = window.document.querySelector('[role="tab"]');
+ const input = window.document.querySelector('input');
+ const detached = window.document.createElement('input');
+
+ // When native form ownership is resolved for each invalid pair
+ const detachedRoot = findTradeFormRoot(tab, detached);
+ const crossDocumentRoot = findTradeFormRoot(tab, second.window.document.querySelector('input'));
+ const unrelatedRoot = findTradeFormRoot(tab, input);
+
+ // Then no body-wide or foreign-document owner is accepted
+ assert.equal(detachedRoot, null);
+ assert.equal(crossDocumentRoot, null);
+ assert.equal(unrelatedRoot, null);
+});
+
+test('user ignores panel-owned and hidden actions when repeated scopes overlap', () => {
+ // Given repeated native scopes contain visible, hidden, and panel-owned buttons
+ const { window } = loadFixtureDom(`
+
+
+
Open
+
Open Long
+ `);
+ const native = window.document.querySelector('#native');
+ const nestedLabel = native.querySelector('#long span');
+
+ // When actions and mode controls are resolved from the same scopes twice
+ const buttons = collectTradeButtonsFromScopes([null, native, native], 'OPEN', { panelId, isVisibleElement });
+ const action = isTradeActionButton(nestedLabel, { panelId });
+ const panelAction = isTradeActionButton(window.document.querySelector(`#${panelId} button`), { panelId });
+ const plainAction = isTradeActionButton(window.document.querySelector('#plain'), { panelId });
+ const missingAction = isTradeActionButton(null, { panelId });
+ const panelTab = isTradeModeTab(window.document.querySelector(`#${panelId} [role="tab"]`), { panelId });
+ const plainTab = isTradeModeTab(window.document.querySelector('#plain'), { panelId });
+
+ // Then only the unique visible native button remains actionable
+ assert.deepEqual(buttons, [native.querySelector('#long')]);
+ assert.equal(action, true);
+ assert.equal(panelAction, false);
+ assert.equal(plainAction, false);
+ assert.equal(missingAction, false);
+ assert.equal(panelTab, false);
+ assert.equal(plainTab, false);
+});
+
+test('user reads one current leverage through overlapping scopes without hidden or panel controls', () => {
+ // Given the native form contains one valid leverage and several ineligible labels
+ const { window } = loadFixtureDom(`
+
+
+
+ `);
+ const root = window.document.querySelector('section');
+
+ // When the current leverage adapter visits repeated and absent scopes
+ const button = findCurrentLeverageButtonFromScopes([null, root, root], { panelId, isVisibleElement });
+ const leverage = parseLeverageButtonText(button.textContent);
+ const absent = findCurrentLeverageButtonFromScopes([null], { panelId, isVisibleElement });
+
+ // Then only the unique current native leverage contributes to the result
+ assert.equal(button, root.querySelector('#leverage'));
+ assert.equal(leverage, 125);
+ assert.equal(absent, null);
+});
+
+for (const { label, mutate } of [
+ { label: 'missing mode group', mutate: (document) => document.querySelector('#position-direction').remove() },
+ { label: 'missing open mode', mutate: (document) => document.querySelector('#position-direction [role="tab"]').remove() },
+ { label: 'missing close mode', mutate: (document) => document.querySelector('#position-direction [role="tab"]:last-child').remove() },
+ { label: 'an extra mode-row child', mutate: (document) => document.querySelector('.trade-mode-row').append(document.createElement('span')) },
+ { label: 'missing leading header controls', mutate: (document) => document.querySelector('.quick-controls').remove() },
+]) {
+ test(`user avoids inserting a panel into a native header with ${label}`, () => {
+ // Given the native header structure has changed from the verified insertion contract
+ const { window } = loadFixtureDom(fixture);
+ mutate(window.document);
+
+ // When the panel adapter resolves its insertion point
+ const insertionPoint = findTradePanelInsertionPoint(window.document);
+
+ // Then the changed structure provides no guessed insertion location
+ assert.equal(insertionPoint, null);
+ });
+}
+
+test('user keeps a correctly placed panel spacer without another DOM insertion', () => {
+ // Given the spacer already occupies the verified location before the native mode row
+ const { window } = loadFixtureDom(fixture);
+ const insertionPoint = findTradePanelInsertionPoint(window.document);
+ const spacer = window.document.createElement('div');
+ insertionPoint.parent.insertBefore(spacer, insertionPoint.before);
+ const observer = new window.MutationObserver(() => {});
+ observer.observe(insertionPoint.parent, { childList: true });
+
+ // When stable rendering places the same spacer again
+ const placed = placeTradePanelSpacer(spacer, insertionPoint);
+ const mutations = observer.takeRecords();
+ observer.disconnect();
+
+ // Then placement succeeds without detaching or reinserting the spacer
+ assert.equal(placed, true);
+ assert.equal(spacer.nextElementSibling, insertionPoint.before);
+ assert.deepEqual(mutations, []);
+});
+
+test('user rejects a stale panel insertion point and missing spacer inputs', () => {
+ // Given React moved the target mode row away from its previously resolved header
+ const { window } = loadFixtureDom(fixture);
+ const insertionPoint = findTradePanelInsertionPoint(window.document);
+ const spacer = window.document.createElement('div');
+ window.document.querySelector('.order-entry').append(insertionPoint.before);
+
+ // When the spacer adapter receives stale or incomplete placement inputs
+ const stale = placeTradePanelSpacer(spacer, insertionPoint);
+ const missingPoint = placeTradePanelSpacer(spacer, null);
+ const missingSpacer = placeTradePanelSpacer(null, insertionPoint);
+
+ // Then no unverified placement moves the spacer into the page
+ assert.equal(stale, false);
+ assert.equal(missingPoint, false);
+ assert.equal(missingSpacer, false);
+ assert.equal(spacer.isConnected, false);
+});
+
+test('user keeps floating panel geometry inside a narrow viewport and rounds fractional anchors', () => {
+ // Given anchors sit beyond a narrow viewport and at fractional positions in a larger one
+ const narrow = { anchorRect: { left: -20, top: 800, width: 200, height: 24 }, panelHeight: 100, viewportWidth: 250, viewportHeight: 300 };
+ const fractional = { anchorRect: { left: 12.4, top: 5.5, width: 300.6, height: 24 }, panelHeight: 0, viewportWidth: 1000, viewportHeight: 700 };
+
+ // When the floating layout uses the current viewport constraints
+ const narrowLayout = calculateFloatingPanelLayout(narrow);
+ const fractionalLayout = calculateFloatingPanelLayout(fractional);
+
+ // Then margins, available width, minimum height, and pixel rounding remain concrete
+ assert.deepEqual(narrowLayout, { width: 234, left: 8, top: 192 });
+ assert.deepEqual(fractionalLayout, { width: 301, left: 12, top: 8 });
+});
+
+test('user receives current trade form state before requiring mutation observation', async () => {
+ // Given an already selected native mode can be read without an observer root
+ const { window } = loadFixtureDom('
Open
');
+ const tab = window.document.querySelector('[role="tab"]');
+
+ // When current and absent state are read through the mutation waiter
+ const selected = await waitForTradeFormMutationState(null, () => window.document.querySelector('[aria-selected="true"]'), 1000);
+ const absent = await waitForTradeFormMutationState(null, () => window.document.querySelector('[data-ready]'), 1000);
+
+ // Then current native state is preserved while absent observation stays unresolved
+ assert.equal(selected, tab);
+ assert.equal(absent, null);
+});
+
+for (const frames of [0, 1.5]) {
+ test(`user rejects the invalid stable frame count ${frames}`, () => {
+ // Given both frame waiters have a valid browser scheduling boundary
+ const { window } = loadFixtureDom('');
+ const root = window.document.querySelector('section');
+ const clock = createAnimationFrameBoundary(window);
+
+ // When the caller requests a nonpositive or fractional stability count
+ const formError = captureThrownError(() => waitForTradeFormFrameState(root, () => root, 1000, frames));
+ const buttonError = captureThrownError(() => waitForTradeActionButtonFrameState(root, () => root.querySelector('button'), isVisibleElement, 1000, frames));
+
+ // Then both public contracts reject before scheduling any browser frame
+ assert.equal(formError.message, '稳定帧数必须为正整数');
+ assert.equal(buttonError.message, '稳定帧数必须为正整数');
+ assert.equal(clock.pendingCount, 0);
+ });
+}
+
+test('user rejects absent frame schedulers and missing action locator dependencies', () => {
+ // Given JSDOM has no frame scheduler until the explicit browser boundary is installed
+ const { window } = loadFixtureDom('');
+ const root = window.document.querySelector('section');
+
+ // When consumers request frame observation without its required dependencies
+ const missingView = captureThrownError(() => waitForTradeFormFrameState(null, () => root, 1000));
+ const missingScheduler = captureThrownError(() => waitForTradeActionButtonFrameState(root, () => root.querySelector('button'), isVisibleElement, 1000));
+ const clock = createAnimationFrameBoundary(window);
+ const missingLocator = captureThrownError(() => waitForTradeActionButtonFrameState(root, null, isVisibleElement, 1000));
+ const missingVisibility = captureThrownError(() => waitForTradeActionButtonFrameState(root, () => root.querySelector('button'), null, 1000));
+
+ // Then each dependency failure remains explicit and no partial wait is scheduled
+ assert.equal(missingView.message, '交易表单帧调度器不可用');
+ assert.equal(missingScheduler.message, '下单按钮帧调度器不可用');
+ assert.equal(missingLocator.message, '下单按钮定位器不可用');
+ assert.equal(missingVisibility.message, '下单按钮定位器不可用');
+ assert.equal(clock.pendingCount, 0);
+});
diff --git a/test/dom/binance-orderbook-trade/trade-form.test.js b/test/dom/binance-orderbook-trade/trade-form.test.js
index 041e769..b05b551 100644
--- a/test/dom/binance-orderbook-trade/trade-form.test.js
+++ b/test/dom/binance-orderbook-trade/trade-form.test.js
@@ -12,28 +12,37 @@ import { isVisibleElement, loadFixtureDom } from '../../helpers/dom.js';
const tradeFormHtml = await readFile(new URL('../../fixtures/binance-orderbook-trade/right-trade-form.html', import.meta.url), 'utf8');
-test('detects open and close mode tabs in the trade form only', () => {
+test("user sees that detects open and close mode tabs in the trade form only", () => {
+ // Given the current trade fields and requested values are available
const { window } = loadFixtureDom(tradeFormHtml);
const tabs = Array.from(window.document.querySelectorAll('[role="tab"]'));
- assert.equal(isTradeModeTab(tabs[0], { panelId: 'jh-binance-close-qty-multiplier-panel' }), true);
+ // When the trade form state is read or synchronized
+ const observed = isTradeModeTab(tabs[0], { panelId: 'jh-binance-close-qty-multiplier-panel' });
+
+ // Then sees that detects open and close mode tabs in the trade form only
+ assert.equal(observed, true);
assert.equal(isTradeModeTab(tabs[1], { panelId: 'jh-binance-close-qty-multiplier-panel' }), true);
});
-test('collects trade action buttons from explicit trade scopes and ignores own panel buttons', () => {
+test("user collects trade action buttons from explicit trade scopes and ignores own panel buttons", () => {
+ // Given the current trade fields and requested values are available
const { window } = loadFixtureDom(tradeFormHtml);
const tradeScope = window.document.querySelector('#trade-form');
const ownPanel = window.document.querySelector('#jh-binance-close-qty-multiplier-panel');
+ // When the trade form state is read or synchronized
const openButtons = collectTradeButtonsFromScopes([tradeScope, ownPanel], 'OPEN', {
panelId: 'jh-binance-close-qty-multiplier-panel',
isVisibleElement,
});
+ // Then collects trade action buttons from explicit trade scopes and ignores own panel buttons
assert.deepEqual(openButtons.map((button) => button.textContent.trim()), ['开多', '开空']);
});
-test('collects the verified English trade action labels', () => {
+test("user collects the verified English trade action labels", () => {
+ // Given the current trade fields and requested values are available
const { window } = loadFixtureDom(`
@@ -48,16 +57,19 @@ test('collects the verified English trade action labels', () => {
panelId: 'jh-binance-close-qty-multiplier-panel',
isVisibleElement,
});
+ // When the trade form state is read or synchronized
const closeButtons = collectTradeButtonsFromScopes([scope], 'CLOSE', {
panelId: 'jh-binance-close-qty-multiplier-panel',
isVisibleElement,
});
+ // Then collects the verified English trade action labels
assert.deepEqual(openButtons.map((button) => button.textContent.trim()), ['Open Long', 'Open Short']);
assert.deepEqual(closeButtons.map((button) => button.textContent.trim()), ['Close Long', 'Close Short']);
});
-test('reads the unique split leverage button from the active trade scope', () => {
+test("user reads the unique split leverage button from the active trade scope", () => {
+ // Given the current trade fields and requested values are available
const { window } = loadFixtureDom(`
@@ -67,17 +79,20 @@ test('reads the unique split leverage button from the active trade scope', () =>
`);
const scope = window.document.querySelector('#trade-form');
+ // When the trade form state is read or synchronized
const button = findCurrentLeverageButtonFromScopes([scope], {
panelId: 'jh-binance-close-qty-multiplier-panel',
isVisibleElement,
});
+ // Then reads the unique split leverage button from the active trade scope
assert.equal(button?.textContent.trim(), '5x');
assert.equal(parseLeverageButtonText(button?.textContent), 5);
assert.equal(parseLeverageButtonText('全仓 5x'), null);
});
-test('rejects ambiguous leverage buttons in the active trade scope', () => {
+test("user rejects ambiguous leverage buttons in the active trade scope", () => {
+ // Given the current trade fields and requested values are available
const { window } = loadFixtureDom(`
@@ -86,8 +101,12 @@ test('rejects ambiguous leverage buttons in the active trade scope', () => {
`);
const scope = window.document.querySelector('#trade-form');
- assert.equal(findCurrentLeverageButtonFromScopes([scope], {
+ // When the trade form state is read or synchronized
+ const observed = findCurrentLeverageButtonFromScopes([scope], {
panelId: 'jh-binance-close-qty-multiplier-panel',
isVisibleElement,
- }), null);
+ });
+
+ // Then rejects ambiguous leverage buttons in the active trade scope
+ assert.equal(observed, null);
});
diff --git a/test/dom/binance-orderbook-trade/usdt-rebalance-dialog.test.js b/test/dom/binance-orderbook-trade/usdt-rebalance-dialog.test.js
index 617cce5..b0849ab 100644
--- a/test/dom/binance-orderbook-trade/usdt-rebalance-dialog.test.js
+++ b/test/dom/binance-orderbook-trade/usdt-rebalance-dialog.test.js
@@ -42,12 +42,15 @@ function createDialogModel() {
};
}
-test('USDT rebalance dialog renders the plan and focuses the safe action', async () => {
+test("user sees that USDT rebalance dialog renders the plan and focuses the safe action", async () => {
+ // Given the account balances and rebalance dialog are available
const dom = createDialogDocument();
const { document } = dom.window;
+ // When the requested dialog interaction executes
const result = showUsdtRebalanceDialog(document, createDialogModel());
const dialog = document.getElementById(USDT_REBALANCE_DIALOG_ID);
+ // Then sees that USDT rebalance dialog renders the plan and focuses the safe action
assert.equal(dialog.tagName, 'DIALOG');
assert.equal(dialog.open, true);
assert.equal(dialog.getAttribute('aria-labelledby'), `${USDT_REBALANCE_DIALOG_ID}-title`);
@@ -65,36 +68,45 @@ test('USDT rebalance dialog renders the plan and focuses the safe action', async
assert.equal(document.getElementById(USDT_REBALANCE_DIALOG_ID), null);
});
-test('USDT rebalance dialog resolves true only from the confirm action', async () => {
+test("user sees that USDT rebalance dialog resolves true only from the confirm action", async () => {
+ // Given the account balances and rebalance dialog are available
const dom = createDialogDocument();
const { document } = dom.window;
const result = showUsdtRebalanceDialog(document, createDialogModel());
+ // When the requested dialog interaction executes
document.querySelector('[data-rebalance-dialog-action="confirm"]').click();
+ // Then sees that USDT rebalance dialog resolves true only from the confirm action
assert.equal(await result, true);
assert.equal(document.getElementById(USDT_REBALANCE_DIALOG_ID), null);
});
-test('USDT rebalance dialog treats Escape as cancellation', async () => {
+test("user sees that USDT rebalance dialog treats Escape as cancellation", async () => {
+ // Given the account balances and rebalance dialog are available
const dom = createDialogDocument();
const { document } = dom.window;
const result = showUsdtRebalanceDialog(document, createDialogModel());
const dialog = document.getElementById(USDT_REBALANCE_DIALOG_ID);
const event = new dom.window.Event('cancel', { cancelable: true });
+ // When the requested dialog interaction executes
dialog.dispatchEvent(event);
+ // Then sees that USDT rebalance dialog treats Escape as cancellation
assert.equal(event.defaultPrevented, true);
assert.equal(await result, false);
assert.equal(document.getElementById(USDT_REBALANCE_DIALOG_ID), null);
});
-test('USDT rebalance dialog rejects concurrent dialogs', async () => {
+test("user sees that USDT rebalance dialog rejects concurrent dialogs", async () => {
+ // Given the account balances and rebalance dialog are available
const dom = createDialogDocument();
const { document } = dom.window;
+ // When the requested dialog interaction executes
const firstResult = showUsdtRebalanceDialog(document, createDialogModel());
+ // Then sees that USDT rebalance dialog rejects concurrent dialogs
assert.throws(
() => showUsdtRebalanceDialog(document, createDialogModel()),
/USDT rebalance dialog is already open/,
diff --git a/test/dom/binance-strategy27-events/compound-candidate-controller.test.js b/test/dom/binance-strategy27-events/compound-candidate-controller.test.js
index 412fb3d..3f61d46 100644
--- a/test/dom/binance-strategy27-events/compound-candidate-controller.test.js
+++ b/test/dom/binance-strategy27-events/compound-candidate-controller.test.js
@@ -5,6 +5,7 @@ import { loadFixtureDom } from '../../helpers/dom.js';
import { createCompoundCandidateController } from '../../../src/binance-strategy27-events/core/compound-candidate-controller.js';
import { createStrategy27EventPanel } from '../../../src/binance-strategy27-events/dom/strategy27-event-panel.js';
import { Strategy27GatewayTransportError } from '../../../src/binance-strategy27-events/core/live-event-client.js';
+import { createStrategyDigestGate } from '../../helpers/strategy-migration-boundaries.js';
const fixtures = JSON.parse(readFileSync(new URL('../../fixtures/strategy27-compound-candidates.json', import.meta.url), 'utf8'));
const EPOCH = 'a'.repeat(32);
@@ -116,10 +117,13 @@ function harness(t, steps, { render, reconcile, createError, removeError, clearE
};
}
-test('controller composes real protocol/lifecycle/panel and renders each independent candidate once', async (t) => {
+test('user observes that controller composes real protocol/lifecycle/panel and renders each independent candidate once', async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
const h = harness(t, [bootstrap(), batch([envelope(fixtures[0], 2), envelope(fixtures[1], 3), envelope(fixtures[0], 4)])]);
+ // When h.run processes the configured inputs
h.run();
await h.parked;
+ // Then user observes that controller composes real protocol/lifecycle/panel and renders each independent candidate once
assert.equal(h.panel.size, 1);
assert.equal(h.panel.compoundSize, 2);
assert.deepEqual([...h.shapes.keys()], fixtures.map((item) => item.candidate_id));
@@ -134,9 +138,12 @@ test('controller composes real protocol/lifecycle/panel and renders each indepen
assert.equal(h.panel.size, 1);
});
-test('unsupported gateways never construct a chart layer and leave ordinary data intact', async (t) => {
+test('user observes that unsupported gateways never construct a chart layer and leave ordinary data intact', async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
const h = harness(t, [{ status: 404, responseText: 'old gateway' }]);
+ // When h.run processes the configured inputs
await h.run();
+ // Then user observes that unsupported gateways never construct a chart layer and leave ordinary data intact
assert.equal(h.calls.length, 1);
assert.equal(h.layerCreates, 0);
assert.equal(h.panel.size, 1);
@@ -145,13 +152,16 @@ test('unsupported gateways never construct a chart layer and leave ordinary data
assert.equal(h.statusKind(), 'inactive');
});
-test('a compound endpoint removed after delivery freezes history without further repairs', async (t) => {
+test('user observes that a compound endpoint removed after delivery freezes history without further repairs', async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
let repairs = 0;
const h = harness(t, [bootstrap(), batch([envelope()]), { status: 404, responseText: 'route removed' }], {
reconcile: () => { repairs += 1; },
});
+ // When h.run processes the configured inputs
await h.run();
await h.controller.reconcile();
+ // Then user observes that a compound endpoint removed after delivery freezes history without further repairs
assert.equal(repairs, 0);
assert.equal(h.panel.compoundSize, 1);
assert.equal(h.shapes.size, 1);
@@ -162,37 +172,45 @@ test('a compound endpoint removed after delivery freezes history without further
assert.equal(h.shapes.size, 0);
});
-test('same-decision panel ordering uses publication time without extending chart retention time', async (t) => {
+test('user observes that same-decision panel ordering uses publication time without extending chart retention time', async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
const high = { ...envelope(fixtures[0], 2), observed_at_ms: 7010 };
const low = { ...envelope(fixtures[1], 3), observed_at_ms: 7020 };
const h = harness(t, [bootstrap(), batch([high, low])]);
+ // When h.setClock processes the configured inputs
h.setClock(7030);
h.run();
await h.parked;
+ // Then user observes that same-decision panel ordering uses publication time without extending chart retention time
assert.deepEqual(h.compoundRows(), [fixtures[1].candidate_id, fixtures[0].candidate_id]);
assert.deepEqual(h.renders.map((item) => item.decisionAtMs), [7000, 7000]);
});
-test('validated 503 recovery merges a new snapshot without deleting compound or ordinary history', async (t) => {
- for (const errorCode of ['compound_unavailable', 'redis_unavailable']) {
+for (const errorCode of ['compound_unavailable', 'redis_unavailable']) {
+ test(`user observes that validated 503 recovery merges a new snapshot without deleting compound or ordinary history (errorCode=${JSON.stringify(errorCode)})`, async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
let recovering;
const h = harness(t, [bootstrap(), batch([envelope()]), response({ schema_version: 1, status: 'error', error_code: errorCode }, 503),
({ panel, shapes, calls }) => {
recovering = { ordinary: panel.size, compound: panel.compoundSize, ids: [...shapes.keys()], hasCursor: calls.at(-1).searchParams.has('cursor') };
return bootstrap('5-0', 'b'.repeat(32));
}, batch([envelope(fixtures[0], 2, 'b'.repeat(32)), envelope(fixtures[1], 3, 'b'.repeat(32))], '5-0', '6-0')]);
+ // When h.run processes the configured inputs
h.run();
await h.parked;
+ // Then user observes that validated 503 recovery merges a new snapshot without deleting compound or ordinary history (errorCode=the selected case)
assert.deepEqual(recovering, { ordinary: 1, compound: 1, ids: [fixtures[0].candidate_id], hasCursor: false });
assert.equal(h.panel.compoundSize, 2);
assert.deepEqual([...h.shapes.keys()], fixtures.map((candidate) => candidate.candidate_id));
assert.equal(h.renders.length, 2);
assert.equal(h.layerClears, 0);
assert.equal(h.status(), '复合候选数据：已连接。接口连通不代表该币种仍在监控中。');
- }
-});
-test('network reconnect retains compound history and original cursor', async (t) => {
+ });
+}
+
+test('user observes that network reconnect retains compound history and original cursor', async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
const h = harness(t, [bootstrap(), batch([envelope()]), new Strategy27GatewayTransportError('fixture connection failure'),
({ panel, shapes, calls }) => {
assert.equal(panel.compoundSize, 1);
@@ -200,16 +218,21 @@ test('network reconnect retains compound history and original cursor', async (t)
assert.equal(calls.at(-1).searchParams.get('cursor'), '2-0');
return batch([envelope(fixtures[0], 3)], '2-0', '3-0');
}]);
+ // When h.run processes the configured inputs
h.run();
await h.parked;
+ // Then user observes that network reconnect retains compound history and original cursor
assert.equal(h.renders.length, 1);
assert.equal(h.panel.size, 1);
});
-test('stream reset retains both candidates and sequence failure freezes their verified history', async (t) => {
+test('user observes that stream reset retains both candidates and sequence failure freezes their verified history', async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
const h = harness(t, [bootstrap(), batch([envelope(), state(1, 'b'.repeat(32)), envelope(fixtures[1], 2, 'b'.repeat(32))]),
batch([envelope(fixtures[0], 2, 'b'.repeat(32))], '2-0', '3-0')]);
+ // When h.run processes the configured inputs
await h.run();
+ // Then user observes that stream reset retains both candidates and sequence failure freezes their verified history
assert.equal(h.renders.length, 2);
assert.equal(h.panel.compoundSize, 2);
assert.deepEqual([...h.shapes.keys()], fixtures.map((candidate) => candidate.candidate_id));
@@ -220,25 +243,32 @@ test('stream reset retains both candidates and sequence failure freezes their ve
assert.equal(h.statusKind(), 'error');
});
-test('contract and lazy renderer failures are terminal only for the compound job', async (t) => {
- for (const mode of ['protocol', 'renderer']) {
+for (const mode of ['protocol', 'renderer']) {
+ test(`user observes that contract and lazy renderer failures are terminal only for the compound job (mode=${JSON.stringify(mode)})`, async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
const h = harness(t, mode === 'protocol' ? [{ status: 200, responseText: 'invalid JSON' }] : [bootstrap(), batch([envelope()])],
mode === 'renderer' ? { createError: new Error('fixture chart capability missing') } : {});
+ // When h.run processes the configured inputs
await h.run();
+ // Then user observes that contract and lazy renderer failures are terminal only for the compound job (mode=the selected case)
assert.equal(h.panel.size, 1);
assert.equal(h.panel.compoundSize, 0);
assert.equal(h.statusKind(), 'error');
assert.match(h.status(), mode === 'renderer' ? /fixture chart capability missing/ : /JSON/);
assert.equal(h.calls.length, mode === 'renderer' ? 2 : 1);
- }
-});
-test('manual clear suppresses pending render and exact replay without restarting the stream', async (t) => {
+ });
+}
+
+test('user observes that manual clear suppresses pending render and exact replay without restarting the stream', async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
const h = harness(t, [bootstrap(), batch([envelope(), envelope(fixtures[0], 3), envelope(fixtures[1], 4)])], {
render: ({ controller, id }) => { if (id === fixtures[0].candidate_id) controller.clear(); },
});
+ // When h.run processes the configured inputs
h.run();
await h.parked;
+ // Then user observes that manual clear suppresses pending render and exact replay without restarting the stream
assert.equal(h.renders.length, 2);
assert.deepEqual([...h.shapes.keys()], [fixtures[1].candidate_id]);
assert.equal(h.panel.compoundSize, 1);
@@ -246,43 +276,45 @@ test('manual clear suppresses pending render and exact replay without restarting
assert.equal(h.calls.length, 3);
});
-test('ordinary clear does not reset compound replay bookkeeping', async (t) => {
+test('user observes that ordinary clear does not reset compound replay bookkeeping', async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
const h = harness(t, [bootstrap(), batch([envelope()]), ({ panel }) => {
panel.clear();
return batch([envelope(fixtures[0], 3)], '2-0', '3-0');
}]);
+ // When h.run processes the configured inputs
h.run();
await h.parked;
+ // Then user observes that ordinary clear does not reset compound replay bookkeeping
assert.equal(h.panel.size, 0);
assert.equal(h.panel.compoundSize, 1);
assert.equal(h.renders.length, 1);
});
-test('manual clear during lifecycle hash validation suppresses late display and later exact replay', async (t) => {
- const validating = deferred();
- const release = deferred();
- const digest = globalThis.crypto.subtle.digest.bind(globalThis.crypto.subtle);
- let digestCalls = 0;
- t.mock.method(globalThis.crypto.subtle, 'digest', async (...args) => {
- digestCalls += 1;
- // Two gateway hashes precede the lifecycle's independent profile hash.
- if (digestCalls === 3) { validating.resolve(); await release.promise; }
- return digest(...args);
- });
+test('user observes that manual clear during lifecycle hash validation suppresses late display and later exact replay', async (t) => {
+ // Two gateway hashes precede the lifecycle's independent profile hash.
+ // Given a compound gateway sequence and independent ordinary event history
+ const gate = createStrategyDigestGate(globalThis.crypto.subtle, 3);
+ const cryptoDescriptor = Object.getOwnPropertyDescriptor(globalThis, 'crypto');
+ Object.defineProperty(globalThis, 'crypto', { configurable: true, value: { subtle: gate.subtle } });
+ t.after(() => Object.defineProperty(globalThis, 'crypto', cryptoDescriptor));
const h = harness(t, [bootstrap(), batch([envelope()]), batch([envelope(fixtures[0], 3)], '2-0', '3-0')]);
+ // When h.run processes the configured inputs
h.run();
- await validating.promise;
+ await gate.entered;
h.controller.clear();
- release.resolve();
+ gate.release();
await h.parked;
- assert.equal(digestCalls, 8);
+ // Then user observes that manual clear during lifecycle hash validation suppresses late display and later exact replay
+ assert.equal(gate.calls.length, 8);
assert.equal(h.renders.length, 0);
assert.equal(h.panel.compoundSize, 0);
assert.equal(h.panel.size, 1);
assert.equal(h.calls.length, 4);
});
-test('stale cursor reset preserves history absent from the new bootstrap and accepts the new stream', async (t) => {
+test('user observes that stale cursor reset preserves history absent from the new bootstrap and accepts the new stream', async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
let recovering;
const h = harness(t, [bootstrap(), batch([envelope()]),
response({ schema_version: 1, status: 'reset', reason: 'stale_cursor', requested_cursor: '2-0', next_cursor: '7-0', messages: [] }, 409),
@@ -290,8 +322,10 @@ test('stale cursor reset preserves history absent from the new bootstrap and acc
recovering = { compound: panel.compoundSize, shapes: shapes.size, ordinary: panel.size };
return bootstrap('7-0', 'b'.repeat(32));
}, batch([envelope(fixtures[1], 2, 'b'.repeat(32))], '7-0', '8-0')]);
+ // When h.run processes the configured inputs
h.run();
await h.parked;
+ // Then user observes that stale cursor reset preserves history absent from the new bootstrap and accepts the new stream
assert.deepEqual(recovering, { compound: 1, shapes: 1, ordinary: 1 });
assert.deepEqual([...h.shapes.keys()], fixtures.map((candidate) => candidate.candidate_id));
assert.equal(h.panel.compoundSize, 2);
@@ -299,8 +333,10 @@ test('stale cursor reset preserves history absent from the new bootstrap and acc
assert.equal(h.statusKind(), 'normal');
});
-test('stop during an asynchronous draw prevents late shapes and panel publication', async (t) => {
+test('user observes that stop during an asynchronous draw prevents late shapes and panel publication', async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
const drawing = deferred();
+ // When deferred processes the configured inputs
const release = deferred();
const h = harness(t, [bootstrap(), batch([envelope()])], { render: async () => { drawing.resolve(); await release.promise; } });
const done = h.run();
@@ -309,14 +345,17 @@ test('stop during an asynchronous draw prevents late shapes and panel publicatio
h.controller.stop('interval_changed');
release.resolve();
await done;
+ // Then user observes that stop during an asynchronous draw prevents late shapes and panel publication
assert.equal(h.panel.compoundSize, 0);
assert.equal(h.shapes.size, 0);
assert.equal(h.panel.size, 1);
assert.equal(h.calls.length, 2);
});
-test('age eviction during a pending draw prevents late publication and needs no new timer', async (t) => {
+test('user observes that age eviction during a pending draw prevents late publication and needs no new timer', async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
const drawing = deferred();
+ // When deferred processes the configured inputs
const release = deferred();
const h = harness(t, [bootstrap(), batch([envelope()])], { maxAgeMs: 1000, render: async () => { drawing.resolve(); await release.promise; } });
h.run();
@@ -325,26 +364,33 @@ test('age eviction during a pending draw prevents late publication and needs no
h.controller.prune();
release.resolve();
await h.parked;
+ // Then user observes that age eviction during a pending draw prevents late publication and needs no new timer
assert.deepEqual(h.removed, [fixtures[0].candidate_id]);
assert.equal(h.panel.compoundSize, 0);
assert.equal(h.shapes.size, 0);
assert.equal(h.panel.size, 1);
});
-test('post-draw age check rejects a candidate that expired while rendering', async (t) => {
+test('user observes that post-draw age check rejects a candidate that expired while rendering', async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
const h = harness(t, [bootstrap(), batch([envelope()])], { maxAgeMs: 1000, render: () => h.setClock(8001) });
+ // When h.run processes the configured inputs
h.run();
await h.parked;
+ // Then user observes that post-draw age check rejects a candidate that expired while rendering
assert.equal(h.panel.compoundSize, 0);
assert.equal(h.shapes.size, 0);
assert.deepEqual(h.removed, [fixtures[0].candidate_id]);
});
-test('timer-driven prune failures stop only the optional job and do not escape to the shared context timer', async (t) => {
+test('user observes that timer-driven prune failures stop only the optional job and do not escape to the shared context timer', async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
const h = harness(t, [bootstrap(), batch([envelope()])], { maxAgeMs: 1000, removeError: new Error('fixture removal failure') });
+ // When h.run processes the configured inputs
const done = h.run();
await h.parked;
h.setClock(8001);
+ // Then user observes that timer-driven prune failures stop only the optional job and do not escape to the shared context timer
assert.doesNotThrow(() => h.controller.prune());
await done;
assert.equal(h.panel.size, 1);
@@ -356,22 +402,28 @@ test('timer-driven prune failures stop only the optional job and do not escape t
assert.match(h.status(), /fixture removal failure/);
});
-test('capacity evictions remove only the evicted compound marker', async (t) => {
+test('user observes that capacity evictions remove only the evicted compound marker', async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
const sorted = [...fixtures].sort((a, b) => a.candidate_id.localeCompare(b.candidate_id));
const h = harness(t, [bootstrap(), batch(sorted.map((item, index) => envelope(item, index + 2)))], { maxCandidates: 1 });
+ // When h.run processes the configured inputs
h.run();
await h.parked;
+ // Then user observes that capacity evictions remove only the evicted compound marker
assert.deepEqual([...h.shapes.keys()], [sorted[1].candidate_id]);
assert.deepEqual(h.removed, [sorted[0].candidate_id]);
assert.equal(h.panel.compoundSize, 1);
assert.equal(h.panel.size, 1);
});
-test('manual clear and stop contain native cleanup failures without retrying removal', async (t) => {
- for (const action of ['clear', 'stop']) {
+for (const action of ['clear', 'stop']) {
+ test(`user observes that manual clear and stop contain native cleanup failures without retrying removal (action=${JSON.stringify(action)})`, async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
const h = harness(t, [bootstrap(), batch([envelope()])], { clearError: new Error('fixture native cleanup failure') });
+ // When h.run processes the configured inputs
const done = h.run();
await h.parked;
+ // Then user observes that manual clear and stop contain native cleanup failures without retrying removal (action=the selected case)
assert.doesNotThrow(() => h.controller[action]('route_changed'));
await done;
assert.equal(h.layerClears, 1);
@@ -379,14 +431,19 @@ test('manual clear and stop contain native cleanup failures without retrying rem
assert.equal(h.panel.compoundSize, 0);
assert.equal(h.statusKind(), 'error');
assert.match(h.status(), /fixture native cleanup failure/);
- }
-});
-test('terminal protocol failure retains history and explicit cleanup preserves both errors', async (t) => {
+ });
+}
+
+test('user observes that terminal protocol failure retains history and explicit cleanup preserves both errors', async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
const h = harness(t, [bootstrap(), batch([envelope()]), { status: 200, responseText: 'invalid JSON' }], {
clearError: new Error('fixture native cleanup failure'),
});
- await assert.doesNotReject(h.run());
+ // When h.run processes the configured inputs
+ const observedResult = h.run();
+ // Then user observes that terminal protocol failure retains history and explicit cleanup preserves both errors
+ await assert.doesNotReject(observedResult);
assert.equal(h.layerClears, 0);
assert.equal(h.panel.size, 1);
assert.equal(h.panel.compoundSize, 1);
@@ -400,8 +457,10 @@ test('terminal protocol failure retains history and explicit cleanup preserves b
assert.match(h.status(), /fixture native cleanup failure/);
});
-test('late drawing failure after context retirement remains inspectable without updating the old panel', async (t) => {
+test('user observes that late drawing failure after context retirement remains inspectable without updating the old panel', async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
const drawing = deferred();
+ // When deferred processes the configured inputs
const release = deferred();
const failure = new Error('fixture late cleanup failure');
const h = harness(t, [bootstrap(), batch([envelope()])], {
@@ -413,6 +472,7 @@ test('late drawing failure after context retirement remains inspectable without
h.controller.stop('route_changed');
const retiredStatus = h.status();
release.resolve();
+ // Then user observes that late drawing failure after context retirement remains inspectable without updating the old panel
await assert.doesNotReject(done);
assert.equal(h.controller.lastError, failure);
assert.equal(h.status(), retiredStatus);
@@ -420,13 +480,16 @@ test('late drawing failure after context retirement remains inspectable without
assert.equal(h.panel.size, 1);
});
-test('timer repair failures stop only the compound job and retain both histories', async (t) => {
+test('user observes that timer repair failures stop only the compound job and retain both histories', async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
const h = harness(t, [bootstrap(), batch([envelope()])], {
reconcile: async () => { throw new Error('fixture native repair failure'); },
});
+ // When h.run processes the configured inputs
h.run();
await h.parked;
await h.controller.reconcile();
+ // Then user observes that timer repair failures stop only the compound job and retain both histories
assert.equal(h.panel.size, 1);
assert.equal(h.panel.compoundSize, 1);
assert.equal(h.shapes.size, 1);
@@ -437,7 +500,8 @@ test('timer repair failures stop only the compound job and retain both histories
assert.match(h.controller.lastError.message, /fixture native repair failure/);
});
-test('manual clear stays effective across unavailable, bootstrap replay and another epoch', async (t) => {
+test('user observes that manual clear stays effective across unavailable, bootstrap replay and another epoch', async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
const epoch = 'b'.repeat(32);
const snapshot = JSON.parse(bootstrap('5-0', epoch).responseText);
snapshot.records = [envelope(fixtures[0], 2, epoch)];
@@ -446,18 +510,23 @@ test('manual clear stays effective across unavailable, bootstrap replay and anot
controller.clear();
return response({ schema_version: 1, status: 'error', error_code: 'redis_unavailable' }, 503);
}, response(snapshot), batch([state(1, 'c'.repeat(32)), envelope(fixtures[0], 2, 'c'.repeat(32)), envelope(fixtures[1], 3, 'c'.repeat(32))], '5-0', '6-0')]);
+ // When h.run processes the configured inputs
h.run();
await h.parked;
+ // Then user observes that manual clear stays effective across unavailable, bootstrap replay and another epoch
assert.deepEqual(h.renders.map((render) => render.id), fixtures.map((candidate) => candidate.candidate_id));
assert.deepEqual([...h.shapes.keys()], [fixtures[1].candidate_id]);
assert.equal(h.panel.compoundSize, 1);
assert.equal(h.layerClears, 1);
});
-test('retained history remains clearable and expires after terminal failure', async (t) => {
- for (const action of ['clear', 'prune', 'stop']) {
+for (const action of ['clear', 'prune', 'stop']) {
+ test(`user observes that retained history remains clearable and expires after terminal failure (action=${JSON.stringify(action)})`, async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
const h = harness(t, [bootstrap(), batch([envelope()]), { status: 200, responseText: 'invalid JSON' }], { maxAgeMs: 1000 });
+ // When h.run processes the configured inputs
await h.run();
+ // Then user observes that retained history remains clearable and expires after terminal failure (action=the selected case)
assert.equal(h.panel.compoundSize, 1);
assert.equal(h.shapes.size, 1);
assert.equal(h.statusKind(), 'error');
@@ -468,18 +537,22 @@ test('retained history remains clearable and expires after terminal failure', as
assert.equal(h.panel.size, 1, action);
assert.match(h.status(), /JSON/);
assert.equal(h.calls.length, 3);
- }
-});
-test('age cleanup attempts every expired candidate once when a native removal fails', async (t) => {
+ });
+}
+
+test('user observes that age cleanup attempts every expired candidate once when a native removal fails', async (t) => {
+ // Given a compound gateway sequence and independent ordinary event history
const h = harness(t, [bootstrap(), batch([envelope(fixtures[0], 2), envelope(fixtures[1], 3)])], {
maxAgeMs: 1000, removeError: new Error('fixture removal failure'),
});
+ // When h.run processes the configured inputs
const done = h.run();
await h.parked;
h.setClock(8001);
h.controller.prune();
await done;
+ // Then user observes that age cleanup attempts every expired candidate once when a native removal fails
assert.deepEqual(h.removed, fixtures.map((candidate) => candidate.candidate_id));
assert.equal(h.panel.compoundSize, 0);
h.controller.prune();
diff --git a/test/dom/binance-strategy27-events/strategy27-entrypoint.test.js b/test/dom/binance-strategy27-events/strategy27-entrypoint.test.js
index 0a2d5b8..d3f5c77 100644
--- a/test/dom/binance-strategy27-events/strategy27-entrypoint.test.js
+++ b/test/dom/binance-strategy27-events/strategy27-entrypoint.test.js
@@ -3,6 +3,7 @@ import { readFileSync } from 'node:fs';
import { runInThisContext } from 'node:vm';
import test from 'node:test';
import { loadFixtureDom } from '../../helpers/dom.js';
+import { createStrategyPromptBoundary, installStrategyClock, observeStrategyQueries } from '../../helpers/strategy-migration-boundaries.js';
const fixtures = JSON.parse(readFileSync(new URL('../../fixtures/strategy27-compound-candidates.json', import.meta.url), 'utf8'));
let importNumber = 0;
@@ -19,6 +20,10 @@ async function harness(t, { generated = false, beforeCreate, locale = 'zh-CN', m
const dom = loadFixtureDom('');
dom.reconfigure({ url: `https://www.binance.com/${locale}/futures/${routeSymbol}` });
const page = dom.window;
+ const clock = installStrategyClock(t, page);
+ const queries = observeStrategyQueries(page.document);
+ const promptBoundary = createStrategyPromptBoundary();
+ page.prompt = promptBoundary.pagePrompt;
if (migrationRecord !== undefined) Object.defineProperty(page, Symbol.for('jh-userscripts.strategy29-preferences-migration'), { value: migrationRecord });
const shapes = new Map([['user-owned', {}]]);
let resolution = '1S';
@@ -45,18 +50,14 @@ async function harness(t, { generated = false, beforeCreate, locale = 'zh-CN', m
}) }) },
};
page.document.querySelector('iframe').contentWindow.tradingViewApi = { activeChart: () => chart };
- const timers = new Map();
+ const timers = clock.intervals;
const menus = new Map();
const menuIds = new Map();
const requests = [];
- const prompts = [];
- let now = 7000;
- t.mock.method(Date, 'now', () => now);
- t.mock.method(page, 'setInterval', (callback, delay) => { assert.equal(delay, 1000); timers.set(1, callback); return 1; });
- t.mock.method(page, 'clearInterval', (id) => timers.delete(id));
+ const prompts = promptBoundary.messages;
const globals = {
unsafeWindow: page,
- prompt: (...args) => { prompts.push(args[0]); return null; },
+ prompt: promptBoundary.sandboxPrompt,
GM_getValue: (key, initial) => key === 'strategy27GatewayAuthSecret' ? 'synthetic-test-value' : initial,
GM_setValue: () => { throw new Error('Unexpected settings write'); },
GM_registerMenuCommand: (name, callback, options = {}) => {
@@ -106,24 +107,27 @@ async function harness(t, { generated = false, beforeCreate, locale = 'zh-CN', m
await until(() => pending('compound').length === 1);
}
return {
- page, chart, shapes, requests, pending, respond, candidate, timers, menus, prompts,
+ page, chart, shapes, requests, pending, respond, candidate, timers, menus, prompts, queries, promptBoundary,
reset: () => respond('compound', { schema_version: 1, status: 'bootstrap', projection_kind: 'compound_candidates', requested_cursor: null, next_cursor: '1-0', runtime_epoch: 'a'.repeat(32), last_sequence: 1, bootstrap_observed_at_ms: 7000, records: [] }),
ordinaryBootstrap: () => respond('ordinary', { schema_version: 1, status: 'bootstrap', projection_kind: 'strategy27_events', requested_cursor: null, next_cursor: '1-0', runtime_epoch: 'a'.repeat(32), last_sequence: 1, bootstrap_observed_at_ms: 7000, records: [] }),
rows: () => page.document.querySelectorAll('[data-role="compound-row"]').length,
- tick: () => timers.get(1)(),
+ tick: () => clock.advance(1000),
clear: () => menus.get('清除 Strategy 27 图表标注')(),
restart: () => menus.get('重新连接 Strategy 27 并恢复历史')(),
- setNow: (value) => { now = value; },
+ setNow: value => clock.setTime(value),
setResolution: (value) => { resolution = value; },
};
}
-test('real entrypoint starts independent clients and manual clear preserves compound replay identity', async (t) => {
+test('user observes that real entrypoint starts independent clients and manual clear preserves compound replay identity', async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t);
assert.equal(h.timers.size, 1);
assert.equal(h.pending('ordinary').length, 1);
+ // When h.reset processes the configured inputs
await h.reset();
await h.candidate();
+ // Then user observes that real entrypoint starts independent clients and manual clear preserves compound replay identity
assert.equal(h.rows(), 1);
assert.equal(h.shapes.size, 3);
h.clear();
@@ -135,25 +139,26 @@ test('real entrypoint starts independent clients and manual clear preserves comp
assert.equal(h.pending('ordinary').length, 1);
});
-test('each context tick discovers the chart root once without restarting healthy clients', async (t) => {
+test('user observes that each context tick discovers the chart root once without restarting healthy clients', async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t);
- let chartRootQueries = 0;
- const query = h.page.document.querySelectorAll.bind(h.page.document);
- t.mock.method(h.page.document, 'querySelectorAll', selector => {
- if (selector === '.chart-widget-root') chartRootQueries += 1;
- return query(selector);
- });
+ // When h.queries.reset processes the configured inputs
+ h.queries.reset();
for (let index = 0; index < 10; index += 1) h.tick();
- assert.equal(chartRootQueries, 10);
+ // Then user observes that each context tick discovers the chart root once without restarting healthy clients
+ assert.equal(h.queries.count('.chart-widget-root'), 10);
assert.equal(h.pending('ordinary').length, 1);
assert.equal(h.pending('compound').length, 1);
});
-test('ordinary failure does not stop compound; the existing timer expires candidates and interval changes abort both', async (t) => {
+test('user observes that ordinary failure does not stop compound; the existing timer expires candidates and interval changes abort both', async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t);
+ // When h.respond processes the configured inputs
await h.respond('ordinary', 'invalid JSON');
await h.reset();
await h.candidate();
+ // Then user observes that ordinary failure does not stop compound; the existing timer expires candidates and interval changes abort both
assert.equal(h.rows(), 1);
h.setNow(7207001);
h.tick();
@@ -168,12 +173,15 @@ test('ordinary failure does not stop compound; the existing timer expires candid
assert.equal(h.shapes.size, 1);
});
-test('an unsupported compound route leaves ordinary polling alive without restarting on each context tick', async (t) => {
+test('user observes that an unsupported compound route leaves ordinary polling alive without restarting on each context tick', async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t);
+ // When h.respond processes the configured inputs
await h.respond('compound', 'missing route', 404);
await until(() => h.page.document.querySelector('[data-role="compound-status"]')?.textContent === '网关尚未启用复合候选');
h.tick();
h.tick();
+ // Then user observes that an unsupported compound route leaves ordinary polling alive without restarting on each context tick
assert.equal(h.requests.filter((request) => request.kind === 'compound').length, 1);
assert.equal(h.pending('ordinary').length, 1);
h.page.history.pushState({}, '', '/zh-CN/markets');
@@ -182,22 +190,28 @@ test('an unsupported compound route leaves ordinary polling alive without restar
assert.equal(h.shapes.size, 1);
});
-test('a disappearing chart root retires both clients and removes only owned entities', async (t) => {
+test('user observes that a disappearing chart root retires both clients and removes only owned entities', async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t);
+ // When h.reset processes the configured inputs
await h.reset();
await h.candidate();
h.page.document.querySelector('.chart-widget-root').setAttribute('data-hidden', '');
h.tick();
+ // Then user observes that a disappearing chart root retires both clients and removes only owned entities
assert.equal(h.pending('ordinary').length, 0);
assert.equal(h.pending('compound').length, 0);
assert.equal(h.rows(), 0);
assert.deepEqual([...h.shapes.keys()], ['user-owned']);
});
-test('generated install artifact receives a candidate and cleans up its paired entities without affecting ordinary polling', async (t) => {
+test('user observes that generated install artifact receives a candidate and cleans up its paired entities without affecting ordinary polling', async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t, { generated: true });
+ // When h.reset processes the configured inputs
await h.reset();
await h.candidate();
+ // Then user observes that generated install artifact receives a candidate and cleans up its paired entities without affecting ordinary polling
assert.equal(h.rows(), 1);
assert.equal(h.shapes.size, 3);
const properties = [...h.shapes.entries()].filter(([id]) => id !== 'user-owned').map(([, shape]) => shape.getProperties());
@@ -216,14 +230,17 @@ test('generated install artifact receives a candidate and cleans up its paired e
});
for (const generated of [false, true]) {
- test(`${generated ? 'generated' : 'source'} context timer restores externally evicted candidates without gateway traffic`, async (t) => {
+ test(`user observes that ${generated ? 'generated' : 'source'} context timer restores externally evicted candidates without gateway traffic`, async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t, { generated });
+ // When h.reset processes the configured inputs
await h.reset();
await h.candidate();
const oldIds = [...h.shapes.keys()].filter((id) => id !== 'user-owned');
for (const id of oldIds) h.shapes.delete(id);
h.tick();
await until(() => h.shapes.size === 3);
+ // Then user observes that the selected case context timer restores externally evicted candidates without gateway traffic
assert.equal(h.rows(), 1);
assert.equal(oldIds.some((id) => h.shapes.has(id)), false);
const repairedIds = [...h.shapes.keys()];
@@ -319,8 +336,10 @@ function compoundMessage(payload = fixtures[0], sequence = 2, epoch = 'a'.repeat
}
for (const generated of [false, true]) {
- test(`${generated ? 'generated' : 'source'} compound recovery retains exact paired entities across epochs, stale cursors and 503`, async (t) => {
+ test(`user observes that ${generated ? 'generated' : 'source'} compound recovery retains exact paired entities across epochs, stale cursors and 503`, async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t, { generated });
+ // When h.ordinaryBootstrap processes the configured inputs
await h.ordinaryBootstrap();
await h.respond('ordinary', { schema_version: 1, status: 'ok', requested_cursor: '1-0', next_cursor: '2-0', messages: [ordinaryMessage()] });
await until(() => h.pending('ordinary').length === 1);
@@ -329,6 +348,7 @@ for (const generated of [false, true]) {
await until(() => h.pending('compound').length === 1);
const ids = [...h.shapes.keys()];
const points = ids.slice(1).map((id) => h.shapes.get(id).getPoints());
+ // Then user observes that the selected case compound recovery retains exact paired entities across epochs, stale cursors and 503
assert.equal(ids.length, 6);
assert.equal(h.rows(), 2);
const epoch = 'b'.repeat(32);
@@ -347,7 +367,6 @@ for (const generated of [false, true]) {
await until(() => h.pending('compound').length === 1);
assert.deepEqual([...h.shapes.keys()], ids);
assert.equal(h.rows(), 2, 'the candidate absent from the new snapshot remains visible');
- t.mock.timers.enable({ apis: ['setTimeout'] });
await h.respond('compound', { schema_version: 1, status: 'error', error_code: 'redis_unavailable' }, 503);
await until(() => h.page.document.querySelector('[data-role="compound-status"]').dataset.state === 'inactive');
assert.deepEqual([...h.shapes.keys()], ids);
@@ -367,12 +386,15 @@ for (const generated of [false, true]) {
assert.equal(h.rows(), 0);
});
- test(`${generated ? 'generated' : 'source'} compound repair failure freezes surviving pairs until clear or context retirement`, async (t) => {
+ test(`user observes that ${generated ? 'generated' : 'source'} compound repair failure freezes surviving pairs until clear or context retirement`, async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t, { generated });
+ // When h.reset processes the configured inputs
await h.reset();
await h.respond('compound', { schema_version: 1, status: 'ok', requested_cursor: '1-0', next_cursor: '2-0', messages: [compoundMessage(fixtures[0], 2), compoundMessage(fixtures[1], 3)] });
await until(() => h.pending('compound').length === 1);
const ids = [...h.shapes.keys()];
+ // Then user observes that the selected case compound repair failure freezes surviving pairs until clear or context retirement
assert.equal(ids.length, 5);
h.shapes.delete(ids[1]);
const create = h.chart.createShape;
@@ -407,8 +429,10 @@ for (const generated of [false, true]) {
assert.equal(h.pending('compound').length, 0);
});
- test(`${generated ? 'generated' : 'source'} refresh bootstrap rebuilds ordinary and compound markers before live polling`, async (t) => {
+ test(`user observes that ${generated ? 'generated' : 'source'} refresh bootstrap rebuilds ordinary and compound markers before live polling`, async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t, { generated });
+ // When ordinaryMessage processes the configured inputs
const ordinary = ordinaryMessage();
const outcome = ordinaryOutcomeMessage();
await h.respond('ordinary', {
@@ -444,6 +468,7 @@ for (const generated of [false, true]) {
records: [compoundMessage()],
});
await until(() => h.shapes.size === 4);
+ // Then user observes that the selected case refresh bootstrap rebuilds ordinary and compound markers before live polling
assert.equal(h.page.document.querySelectorAll('[data-role="event-row"]').length, 1);
assert.equal(h.rows(), 1);
assert.equal(h.pending('ordinary').length, 1);
@@ -456,11 +481,14 @@ for (const generated of [false, true]) {
}
for (const generated of [false, true]) {
- test(`${generated ? 'generated' : 'source'} timer restores ordinary drawings and prunes both lifecycles before repair`, async (t) => {
+ test(`user observes that ${generated ? 'generated' : 'source'} timer restores ordinary drawings and prunes both lifecycles before repair`, async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t, { generated });
+ // When h.ordinaryBootstrap processes the configured inputs
await h.ordinaryBootstrap();
await h.respond('ordinary', { schema_version: 1, status: 'ok', requested_cursor: '1-0', next_cursor: '2-0', messages: [ordinaryMessage()] });
await until(() => h.shapes.size === 2 || h.page.document.getElementById('jh-strategy27-event-status')?.dataset.state === 'error');
+ // Then user observes that the selected case timer restores ordinary drawings and prunes both lifecycles before repair
assert.equal(h.shapes.size, 2, h.page.document.getElementById('jh-strategy27-event-status')?.textContent);
const oldOrdinary = [...h.shapes.keys()].find((id) => id !== 'user-owned');
h.shapes.delete(oldOrdinary);
@@ -481,10 +509,12 @@ for (const generated of [false, true]) {
});
}
-test('timer expiry cancels an ordinary first creation that is still awaiting TradingView', async (t) => {
+test('user observes that timer expiry cancels an ordinary first creation that is still awaiting TradingView', async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const entered = Promise.withResolvers();
const release = Promise.withResolvers();
const h = await harness(t, { beforeCreate: async () => { entered.resolve(); await release.promise; } });
+ // When h.ordinaryBootstrap processes the configured inputs
await h.ordinaryBootstrap();
await h.respond('ordinary', { schema_version: 1, status: 'ok', requested_cursor: '1-0', next_cursor: '2-0', messages: [ordinaryMessage()] });
await entered.promise;
@@ -492,26 +522,29 @@ test('timer expiry cancels an ordinary first creation that is still awaiting Tra
h.tick();
release.resolve();
await until(() => h.pending('ordinary').length === 1);
+ // Then user observes that timer expiry cancels an ordinary first creation that is still awaiting TradingView
assert.deepEqual([...h.shapes.keys()], ['user-owned']);
assert.equal(h.page.document.querySelectorAll('[data-role="event-row"]').length, 0);
});
for (const generated of [false, true]) {
- test(`${generated ? 'generated' : 'source'} live 503 retains ordinary history and resumes at the same cursor`, async (t) => {
+ test(`user observes that ${generated ? 'generated' : 'source'} live 503 retains ordinary history and resumes at the same cursor`, async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t, { generated });
+ // When h.ordinaryBootstrap processes the configured inputs
await h.ordinaryBootstrap();
await h.respond('ordinary', { schema_version: 1, status: 'ok', requested_cursor: '1-0', next_cursor: '2-0', messages: [ordinaryMessage()] });
await until(() => h.pending('ordinary').length === 1);
const ids = [...h.shapes.keys()];
+ // Then user observes that the selected case live 503 retains ordinary history and resumes at the same cursor
assert.equal(ids.length, 2);
- t.mock.timers.enable({ apis: ['setTimeout'] });
await h.respond('ordinary', { schema_version: 1, status: 'error', error_code: 'redis_unavailable' }, 503);
await until(() => h.page.document.getElementById('jh-strategy27-event-status') !== null);
assert.equal(h.page.document.getElementById('jh-strategy27-event-status').dataset.state, 'inactive');
h.tick();
assert.deepEqual([...h.shapes.keys()], ids);
assert.equal(h.page.document.querySelectorAll('[data-role="event-row"]').length, 1);
- t.mock.timers.tick(1999);
+ t.mock.timers.tick(999);
assert.equal(h.pending('ordinary').length, 0);
t.mock.timers.tick(1);
await until(() => h.pending('ordinary').length === 1);
@@ -523,13 +556,16 @@ for (const generated of [false, true]) {
assert.equal(h.page.document.getElementById('jh-strategy27-event-status'), null);
});
- test(`${generated ? 'generated' : 'source'} fatal repair preserves surviving history until expiry or explicit restart`, async (t) => {
+ test(`user observes that ${generated ? 'generated' : 'source'} fatal repair preserves surviving history until expiry or explicit restart`, async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t, { generated });
+ // When h.ordinaryBootstrap processes the configured inputs
await h.ordinaryBootstrap();
const first = ordinaryMessage();
const second = { ...ordinaryMessage(), event_id: 'c'.repeat(64), sequence: 3 };
await h.respond('ordinary', { schema_version: 1, status: 'ok', requested_cursor: '1-0', next_cursor: '3-0', messages: [first, second] });
await until(() => h.pending('ordinary').length === 1);
+ // Then user observes that the selected case fatal repair preserves surviving history until expiry or explicit restart
assert.equal(h.shapes.size, 3);
const ids = [...h.shapes.keys()].filter((id) => id !== 'user-owned');
h.shapes.delete(ids[0]);
@@ -569,12 +605,15 @@ function ordinaryStreamReset(epoch = 'c'.repeat(32)) {
}
for (const generated of [false, true]) {
- test(`${generated ? 'generated' : 'source'} transport epoch reset retains historical arrows and rehydrates without duplication`, async (t) => {
+ test(`user observes that ${generated ? 'generated' : 'source'} transport epoch reset retains historical arrows and rehydrates without duplication`, async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t, { generated });
+ // When h.ordinaryBootstrap processes the configured inputs
await h.ordinaryBootstrap();
await h.respond('ordinary', { schema_version: 1, status: 'ok', requested_cursor: '1-0', next_cursor: '2-0', messages: [ordinaryMessage()] });
await until(() => h.pending('ordinary').length === 1);
const ids = [...h.shapes.keys()];
+ // Then user observes that the selected case transport epoch reset retains historical arrows and rehydrates without duplication
assert.equal(ids.length, 2);
await h.respond('ordinary', { schema_version: 1, status: 'ok', requested_cursor: '2-0', next_cursor: '3-0', messages: [ordinaryStreamReset()] });
await until(() => h.pending('ordinary').length === 1);
@@ -598,8 +637,10 @@ for (const generated of [false, true]) {
}
for (const generated of [false, true]) {
- test(`${generated ? 'generated' : 'source'} stale cursor bootstrap merges retained history and context exit removes it`, async (t) => {
+ test(`user observes that ${generated ? 'generated' : 'source'} stale cursor bootstrap merges retained history and context exit removes it`, async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t, { generated });
+ // When h.ordinaryBootstrap processes the configured inputs
await h.ordinaryBootstrap();
const ordinary = ordinaryMessage();
await h.respond('ordinary', { schema_version: 1, status: 'ok', requested_cursor: '1-0', next_cursor: '2-0', messages: [ordinary] });
@@ -607,6 +648,7 @@ for (const generated of [false, true]) {
const ids = [...h.shapes.keys()];
await h.respond('ordinary', { schema_version: 1, status: 'reset', reason: 'stale_cursor', requested_cursor: '2-0', next_cursor: '5-0', messages: [] }, 409);
await until(() => h.pending('ordinary').length === 1);
+ // Then user observes that the selected case stale cursor bootstrap merges retained history and context exit removes it
assert.deepEqual([...h.shapes.keys()], ids);
await h.respond('ordinary', { schema_version: 1, status: 'bootstrap', projection_kind: 'strategy27_events', requested_cursor: null,
next_cursor: '6-0', runtime_epoch: ordinary.runtime_epoch, last_sequence: 2, bootstrap_observed_at_ms: 7000,
@@ -620,12 +662,15 @@ for (const generated of [false, true]) {
assert.equal(h.page.document.querySelectorAll('[data-role="event-row"]').length, 0);
});
- test(`${generated ? 'generated' : 'source'} retained display history stays bounded across epochs and manual clear removes it`, async (t) => {
+ test(`user observes that ${generated ? 'generated' : 'source'} retained display history stays bounded across epochs and manual clear removes it`, async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t, { generated });
+ // When h.ordinaryBootstrap processes the configured inputs
await h.ordinaryBootstrap();
const messages = Array.from({ length: 80 }, (_, i) => ({ ...ordinaryMessage(), sequence: i + 2, event_id: i.toString(16).padStart(64, '0') }));
await h.respond('ordinary', { schema_version: 1, status: 'ok', requested_cursor: '1-0', next_cursor: '81-0', messages });
await until(() => h.pending('ordinary').length === 1);
+ // Then user observes that the selected case retained display history stays bounded across epochs and manual clear removes it
assert.equal(h.shapes.size, 81);
const firstId = [...h.shapes.keys()][1];
await h.respond('ordinary', { schema_version: 1, status: 'ok', requested_cursor: '81-0', next_cursor: '82-0', messages: [ordinaryStreamReset()] });
@@ -645,8 +690,10 @@ for (const generated of [false, true]) {
});
}
-test('display capacity uses last observation rather than insertion order after epoch rehydration', async (t) => {
+test('user observes that display capacity uses last observation rather than insertion order after epoch rehydration', async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t);
+ // When h.ordinaryBootstrap processes the configured inputs
await h.ordinaryBootstrap();
const events = Array.from({ length: 80 }, (_, i) => ({ ...ordinaryMessage(), sequence: i + 2, event_id: i.toString(16).padStart(64, '0') }));
await h.respond('ordinary', { schema_version: 1, status: 'ok', requested_cursor: '1-0', next_cursor: '81-0', messages: events });
@@ -656,6 +703,7 @@ test('display capacity uses last observation rather than insertion order after e
await until(() => h.pending('ordinary').length === 1);
await h.respond('ordinary', { schema_version: 1, status: 'ok', requested_cursor: '82-0', next_cursor: '83-0', messages: [{ ...ordinaryMessage(), runtime_epoch: 'c'.repeat(32), sequence: 3, observed_at_ms: 7000 }] });
await until(() => h.pending('ordinary').length === 1);
+ // Then user observes that display capacity uses last observation rather than insertion order after epoch rehydration
assert.equal(h.shapes.size, 81);
assert.equal(h.shapes.has(ids[1]), true);
assert.equal(h.shapes.has(ids[2]), false);
@@ -666,8 +714,10 @@ test('display capacity uses last observation rather than insertion order after e
assert.equal(h.shapes.has(ids[1]), true);
});
-test('older bootstrap replay cannot shorten the retained display lifetime', async (t) => {
+test('user observes that older bootstrap replay cannot shorten the retained display lifetime', async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t);
+ // When h.ordinaryBootstrap processes the configured inputs
await h.ordinaryBootstrap();
await h.respond('ordinary', { schema_version: 1, status: 'ok', requested_cursor: '1-0', next_cursor: '2-0', messages: [{ ...ordinaryMessage(), observed_at_ms: 7000 }] });
await until(() => h.pending('ordinary').length === 1);
@@ -682,6 +732,7 @@ test('older bootstrap replay cannot shorten the retained display lifetime', asyn
h.setNow(7202001);
h.tick();
await new Promise(setImmediate);
+ // Then user observes that older bootstrap replay cannot shorten the retained display lifetime
assert.deepEqual([...h.shapes.keys()], ids);
assert.equal(h.page.document.querySelectorAll('[data-role="event-row"]').length, 1);
h.setNow(7207001);
@@ -692,15 +743,18 @@ test('older bootstrap replay cannot shorten the retained display lifetime', asyn
});
for (const generated of [false, true]) {
- test(`${generated ? 'generated' : 'source'} removed-symbol bootstrap exposes monitoring status across stream reset`, async (t) => {
+ test(`user observes that ${generated ? 'generated' : 'source'} removed-symbol bootstrap exposes monitoring status across stream reset`, async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t, { generated });
const removed = { ...ordinaryMessage(), message_kind: 'event_closed', data_status: 'incomplete',
payload: { event: { ...ordinaryOutcomeMessage().payload.event, event_status: 'incomplete', close_reason: 'universe_removed' } } };
+ // When h.respond processes the configured inputs
await h.respond('ordinary', { schema_version: 1, status: 'bootstrap', projection_kind: 'strategy27_events', requested_cursor: null,
next_cursor: '2-0', runtime_epoch: removed.runtime_epoch, last_sequence: 2, bootstrap_observed_at_ms: 7000,
records: [{ event_id: removed.event_id, event_envelope: removed, marker_envelope: removed, outcome_envelope: null }] });
await until(() => h.pending('ordinary').length === 1);
const status = h.page.document.querySelector('[data-role="ordinary-monitoring-status"]');
+ // Then user observes that the selected case removed-symbol bootstrap exposes monitoring status across stream reset
assert.equal(status?.dataset.state, 'removed');
assert.match(status.textContent, /已移出监控范围/);
await h.respond('ordinary', { schema_version: 1, status: 'ok', requested_cursor: '2-0', next_cursor: '3-0', messages: [ordinaryStreamReset()] });
@@ -715,8 +769,10 @@ for (const generated of [false, true]) {
}
for (const generated of [false, true]) {
- test(`${generated ? 'generated' : 'source'} outcome-only bootstrap restores removed-symbol status`, async (t) => {
+ test(`user observes that ${generated ? 'generated' : 'source'} outcome-only bootstrap restores removed-symbol status`, async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t, { generated });
+ // When ordinaryOutcomeMessage processes the configured inputs
const outcome = ordinaryOutcomeMessage();
outcome.data_status = 'terminated';
outcome.payload.event.event_status = 'incomplete';
@@ -726,19 +782,23 @@ for (const generated of [false, true]) {
next_cursor: '3-0', runtime_epoch: outcome.runtime_epoch, last_sequence: 3, bootstrap_observed_at_ms: 7000,
records: [{ event_id: outcome.event_id, event_envelope: outcome, marker_envelope: null, outcome_envelope: outcome }] });
await until(() => h.pending('ordinary').length === 1);
+ // Then user observes that the selected case outcome-only bootstrap restores removed-symbol status
assert.equal(h.page.document.querySelector('[data-role="ordinary-monitoring-status"]').dataset.state, 'removed');
assert.equal(h.page.document.querySelector('[data-role="ordinary-connection-status"]').dataset.state, 'connected');
});
}
for (const generated of [false, true]) {
- test(`${generated ? 'generated' : 'source'} English route localizes ordinary and compound content and language switching updates menus`, async (t) => {
+ test(`user observes that ${generated ? 'generated' : 'source'} English route localizes ordinary and compound content and language switching updates menus`, async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t, { generated, locale: 'en' });
+ // When h.ordinaryBootstrap processes the configured inputs
await h.ordinaryBootstrap();
await h.respond('ordinary', { schema_version: 1, status: 'ok', requested_cursor: '1-0', next_cursor: '2-0', messages: [ordinaryMessage()] });
await until(() => h.pending('ordinary').length === 1);
await h.reset(); await h.candidate();
const panel = () => h.page.document.getElementById('jh-strategy27-event-panel');
+ // Then user observes that the selected case English route localizes ordinary and compound content and language switching updates menus
assert.doesNotMatch(panel().textContent, /\p{Script=Han}/u);
assert.match(panel().textContent, /Compound|candidate/i);
h.page.document.querySelector('[data-role="event-row"]').click();
@@ -774,24 +834,29 @@ for (const generated of [false, true]) {
}
for (const generated of [false, true]) {
- test(`${generated ? 'generated' : 'source'} ignores retired preference records and provides only the shared transport`, async (t) => {
+ test(`user observes that ${generated ? 'generated' : 'source'} ignores retired preference records and provides only the shared transport`, async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t, { generated, migrationRecord: { version: 1, enabled: true, position: null, secret: 'synthetic-rejected-value' } });
assert.equal(h.page[Symbol.for('jh-userscripts.signal-gateway')].version, 1);
assert.equal(h.page.__TM_SIGNAL_CLIENT_DEBUG__, undefined);
assert.equal(h.pending('ordinary').length, 1);
assert.equal(h.pending('compound').length, 1);
+ // When h.ordinaryBootstrap processes the configured inputs
await h.ordinaryBootstrap();
await until(() => h.pending('ordinary').length === 1);
+ // Then user observes that the selected case ignores retired preference records and provides only the shared transport
assert.equal(h.pending('ordinary').length, 1);
assert.equal(h.page.document.querySelectorAll('#jh-strategy29-summary-panel').length, 0);
});
- test(`${generated ? 'generated' : 'source'} locale switch updates stopped status and prompts without reconnecting`, async (t) => {
+ test(`user observes that ${generated ? 'generated' : 'source'} locale switch updates stopped status and prompts without reconnecting`, async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const h = await harness(t, { generated, locale: 'en' });
const prompts = h.prompts;
- t.mock.method(h.page, 'prompt', () => { throw new Error('Page prompt must not receive private input'); });
+ // When h.menus.get('Set CorsairQuant gateway secret') processes the configured inputs
h.menus.get('Set CorsairQuant gateway secret')();
h.menus.get('Set CorsairQuant local gateway URL')();
+ // Then user observes that the selected case locale switch updates stopped status and prompts without reconnecting
assert.equal(prompts.length, 2);
assert.doesNotMatch(prompts.join(' '), /\p{Script=Han}/u);
await h.respond('ordinary', 'invalid JSON');
@@ -808,18 +873,22 @@ for (const generated of [false, true]) {
assert.match(prompts[2], /输入 CorsairQuant/);
assert.match(prompts[3], /输入 SSH/);
assert.equal(h.menus.size, 4);
+ assert.deepEqual(h.promptBoundary.pageAttempts, []);
});
}
for (const generated of [false, true]) {
-test(`${generated ? 'generated' : 'source'} Unicode URL and chart symbol start both clients and draw the Python candidate`, async (t) => {
+test(`user observes that ${generated ? 'generated' : 'source'} Unicode URL and chart symbol start both clients and draw the Python candidate`, async (t) => {
+ // Given the Binance page, gateway requests and Strategy 27 installation
const candidateFixture = JSON.parse(readFileSync(new URL('../../fixtures/strategy27-unicode-candidate.json', import.meta.url), 'utf8'));
const h = await harness(t, {generated, routeSymbol: '币安人生USDT', candidateFixture});
assert.equal(h.pending('ordinary').length, 1);
assert.equal(h.pending('compound').length, 1);
+ // When h.reset processes the configured inputs
await h.reset();
await h.candidate();
+ // Then user observes that the selected case Unicode URL and chart symbol start both clients and draw the Python candidate
assert.equal(h.rows(), 1);
assert.equal(h.shapes.size, 3);
assert.ok(h.requests.every((request) => new URL(request.options.url).searchParams.get('symbol') === candidateFixture.symbol));
diff --git a/test/dom/binance-strategy27-events/strategy27-event-panel.test.js b/test/dom/binance-strategy27-events/strategy27-event-panel.test.js
index 3d681a3..80bff03 100644
--- a/test/dom/binance-strategy27-events/strategy27-event-panel.test.js
+++ b/test/dom/binance-strategy27-events/strategy27-event-panel.test.js
@@ -1,7 +1,10 @@
import assert from 'node:assert/strict';
import test from 'node:test';
+import { JSDOM } from 'jsdom';
import { loadFixtureDom } from '../../helpers/dom.js';
+import { captureStrategyError } from '../../helpers/strategy-migration-boundaries.js';
+import { createLocalizedAnnotation } from '../../../src/binance-strategy27-events/core/ui-copy.js';
import { createStrategy27EventPanel } from '../../../src/binance-strategy27-events/dom/strategy27-event-panel.js';
function annotation({ time = 1_000, summary = '价格 +4.2 bps · 点差 1.2 bps' } = {}) {
@@ -34,9 +37,11 @@ function panelOptions(maxEvents, overrides = {}) {
};
}
-test('renders one fixed detail panel and a bounded recent-event list', () => {
+test('user renders one fixed detail panel and a bounded recent-event list', () => {
+ // Given the Strategy 27 panel and its event records
const dom = loadFixtureDom('');
const { document } = dom.window;
+ // When document.querySelector processes the configured inputs
const chartRoot = document.querySelector('.chart-widget-root');
const panel = createStrategy27EventPanel(dom.window.document, chartRoot, panelOptions(2));
@@ -44,6 +49,7 @@ test('renders one fixed detail panel and a bounded recent-event list', () => {
panel.upsert('event-b', annotation({ time: 2_000, summary: '价格 -2.8 bps · 点差 2.3 bps' }), 2_100);
panel.upsert('event-c', annotation({ time: 3_000, summary: '价格 +0.04 bps · 点差 1.1 bps' }), 3_100);
+ // Then user renders one fixed detail panel and a bounded recent-event list
assert.equal(document.querySelectorAll('#jh-strategy27-event-panel').length, 1);
assert.equal(document.querySelectorAll('[data-role="event-row"]').length, 2);
assert.match(document.querySelector('[data-role="event-detail"]').textContent, /\+0\.04 bps/);
@@ -71,7 +77,8 @@ function compoundAnnotation(time, family = '买入推动失效') {
};
}
-test('ordinary and compound histories have independent bounds and reset ownership', () => {
+test('user observes that ordinary and compound histories have independent bounds and reset ownership', () => {
+ // Given the Strategy 27 panel and its event records
const dom = loadFixtureDom('');
const { document } = dom.window;
const panel = createStrategy27EventPanel(document, document.querySelector('.chart-widget-root'), panelOptions(8));
@@ -84,7 +91,9 @@ test('ordinary and compound histories have independent bounds and reset ownershi
assert.equal(document.querySelectorAll('[data-role="event-row"]').length, 8);
assert.equal(document.querySelectorAll('[data-role="compound-row"]').length, 8);
assert.equal(document.querySelector('[data-event-id="candidate-0"]'), null);
+ // When panel.clear processes the configured inputs
panel.clear();
+ // Then user observes that ordinary and compound histories have independent bounds and reset ownership
assert.equal(panel.size, 0);
assert.equal(panel.compoundSize, 8);
assert.equal(document.querySelectorAll('[data-role="compound-row"]').length, 8);
@@ -96,14 +105,17 @@ test('ordinary and compound histories have independent bounds and reset ownershi
panel.destroy();
});
-test('compound connection status survives ordinary updates and both streams expose selectable detail', () => {
+test('user observes that compound connection status survives ordinary updates and both streams expose selectable detail', () => {
+ // Given the Strategy 27 panel and its event records
const dom = loadFixtureDom('');
const { document } = dom.window;
const panel = createStrategy27EventPanel(document, document.querySelector('.chart-widget-root'), panelOptions(8));
+ // When panel.upsertCompound processes the configured inputs
panel.upsertCompound('impact', compoundAnnotation(7000), 8000);
panel.upsertCompound('passive', compoundAnnotation(7000, '被动承接转弱'), 8000);
panel.setCompoundStatus('复合候选不可用，正在重连', 'inactive');
panel.upsert('ordinary', annotation({ time: 9000 }), 9000);
+ // Then user observes that compound connection status survives ordinary updates and both streams expose selectable detail
assert.equal(document.querySelector('[data-role="compound-status"]').textContent, '复合候选不可用，正在重连');
const rows = [...document.querySelectorAll('[data-role="compound-row"]')];
assert.equal(rows.length, 2);
@@ -121,9 +133,11 @@ test('compound connection status survives ordinary updates and both streams expo
panel.destroy();
});
-test('keeps a manually selected event until follow-latest is restored', () => {
+test('user keeps a manually selected event until follow-latest is restored', () => {
+ // Given the Strategy 27 panel and its event records
const dom = loadFixtureDom('');
const { document } = dom.window;
+ // When document.querySelector processes the configured inputs
const chartRoot = document.querySelector('.chart-widget-root');
const panel = createStrategy27EventPanel(dom.window.document, chartRoot, panelOptions(3));
@@ -134,6 +148,7 @@ test('keeps a manually selected event until follow-latest is restored', () => {
eventA.click();
panel.upsert('event-c', annotation({ time: 3_000, summary: '价格 +3.0 bps · 点差 1.0 bps' }), 3_100);
+ // Then user keeps a manually selected event until follow-latest is restored
assert.match(document.querySelector('[data-role="event-detail"]').textContent, /\+1\.0 bps/);
document.querySelector('[data-role="follow-latest"]').click();
assert.match(document.querySelector('[data-role="event-detail"]').textContent, /\+3\.0 bps/);
@@ -145,9 +160,11 @@ test('keeps a manually selected event until follow-latest is restored', () => {
assert.equal(document.querySelector('#jh-strategy27-event-panel'), null);
});
-test('drags the panel by its header, persists the bounded position, and ignores header buttons', () => {
+test('user drags the panel by its header and persists its bounded position without dragging header buttons', () => {
+ // Given the Strategy 27 panel and its event records
const dom = loadFixtureDom('');
const { document } = dom.window;
+ // When document.querySelector processes the configured inputs
const chartRoot = document.querySelector('.chart-widget-root');
Object.defineProperties(dom.window, {
innerWidth: { configurable: true, value: 500 },
@@ -180,6 +197,7 @@ test('drags the panel by its header, persists the bounded position, and ignores
return { left, right: left + 320, top, bottom: top + 200, width: 320, height: 200 };
};
+ // Then user drags the panel by its header and persists its bounded position without dragging header buttons
assert.equal(panel.style.position, 'fixed');
assert.equal(panel.style.left, '100px');
assert.equal(panel.style.top, '120px');
@@ -231,16 +249,19 @@ test('drags the panel by its header, persists the bounded position, and ignores
assert.equal(savedPositions.length, 1);
});
-test('transport history marking preserves selection, facts, bounds and compound ownership', () => {
+test('user observes that transport history marking preserves selection, facts, bounds and compound ownership', () => {
+ // Given the Strategy 27 panel and its event records
const dom = loadFixtureDom('');
const { document } = dom.window;
const panel = createStrategy27EventPanel(document, document.querySelector('.chart-widget-root'), panelOptions(2));
+ // When panel.upsert processes the configured inputs
panel.upsert('old', { ...annotation(), status: 'active' }, 1100);
panel.upsert('latest', { ...annotation({ time: 2000 }), status: 'complete' }, 2100);
panel.upsertCompound('compound', compoundAnnotation(3000), 3100);
document.querySelector('[data-event-id="old"]').click();
panel.retainHistory();
panel.retainHistory();
+ // Then user observes that transport history marking preserves selection, facts, bounds and compound ownership
assert.equal(panel.size, 2);
assert.equal(panel.compoundSize, 1);
const detail = document.querySelector('[data-role="event-detail"]');
@@ -257,16 +278,19 @@ test('transport history marking preserves selection, facts, bounds and compound
dom.window.close();
});
-test('monitoring status remains independent of selected history and connection recovery', () => {
+test('user observes that monitoring status remains independent of selected history and connection recovery', () => {
+ // Given the Strategy 27 panel and its event records
const dom = loadFixtureDom('');
const { document } = dom.window;
const panel = createStrategy27EventPanel(document, document.querySelector('.chart-widget-root'), panelOptions(2));
const removed = { triggered_at_ms: 2000, event_status: 'incomplete', close_reason: 'universe_removed' };
+ // When panel.upsert processes the configured inputs
panel.upsert('old', annotation({ time: 1000 }), 1100);
panel.upsert('removed', annotation({ time: 2000 }), 3000);
panel.observeOrdinaryEvent(removed, 3000);
const monitoring = document.querySelector('[data-role="ordinary-monitoring-status"]');
const connection = document.querySelector('[data-role="ordinary-connection-status"]');
+ // Then user observes that monitoring status remains independent of selected history and connection recovery
assert.equal(monitoring.dataset.state, 'removed');
assert.match(monitoring.textContent, /已移出监控范围/);
document.querySelector('[data-event-id="old"]').click();
@@ -294,3 +318,206 @@ test('monitoring status remains independent of selected history and connection r
panel.destroy();
dom.window.close();
});
+
+for (const [field, value] of [
+ ['maxEvents', 0], ['maxEvents', 1.5],
+ ['maxCompoundEvents', 0], ['maxCompoundEvents', 9],
+ ['loadPosition', null], ['savePosition', null],
+]) {
+ test(`user rejects invalid panel option ${field}=${value} before creating the panel`, (t) => {
+ // Given the requested panel dependency or capacity violates its public contract
+ const dom = loadFixtureDom('');
+ t.after(() => dom.window.close());
+ const { document } = dom.window;
+ const options = panelOptions(2, { [field]: value });
+
+ // When the panel is created with the invalid option
+ const failure = captureStrategyError(() => createStrategy27EventPanel(document, document.querySelector('.chart-widget-root'), options));
+
+ // Then the invalid option is identified and no panel has been mounted
+ assert.equal(failure.message, `Strategy 27 panel ${field} is invalid`);
+ assert.equal(document.getElementById('jh-strategy27-event-panel'), null);
+ });
+}
+
+for (const [label, position] of [
+ ['missing position', undefined], ['text position', '100,200'],
+ ['non-finite left coordinate', { left: Infinity, top: 0 }],
+ ['text top coordinate', { left: 0, top: '200' }],
+]) {
+ test(`user receives an explicit error for a stored ${label}`, (t) => {
+ // Given the saved position is not a valid pair of numeric coordinates
+ const dom = loadFixtureDom('');
+ t.after(() => dom.window.close());
+ const { document } = dom.window;
+ const options = panelOptions(2, { loadPosition: () => position });
+
+ // When the panel restores its persisted position
+ const failure = captureStrategyError(() => createStrategy27EventPanel(document, document.querySelector('.chart-widget-root'), options));
+
+ // Then malformed persisted coordinates are rejected explicitly
+ assert.equal(failure.message, 'Strategy 27 panel position is invalid');
+ });
+}
+
+test('user cannot mount the panel into a document without a browsing context', (t) => {
+ // Given a real detached HTML document has no associated window
+ const dom = new JSDOM('');
+ t.after(() => dom.window.close());
+ const document = dom.window.document.implementation.createHTMLDocument('Detached');
+ const chartRoot = document.createElement('div');
+ document.body.append(chartRoot);
+ assert.equal(document.defaultView, null);
+
+ // When panel placement requires the unavailable viewport
+ const failure = captureStrategyError(() => createStrategy27EventPanel(document, chartRoot, panelOptions(2)));
+
+ // Then the missing window is reported without inventing viewport dimensions
+ assert.equal(failure.message, 'Strategy 27 panel window is unavailable');
+});
+
+test('user keeps a restored panel inside the viewport before native layout has measured its size', (t) => {
+ // Given native JSDOM geometry has zero dimensions and the saved position lies outside the viewport
+ const dom = new JSDOM('');
+ t.after(() => dom.window.close());
+ const { document } = dom.window;
+ const chartRoot = document.querySelector('.chart-widget-root');
+ assert.equal(chartRoot.offsetWidth, 0);
+ assert.equal(chartRoot.offsetHeight, 0);
+
+ // When the panel restores an out-of-bounds saved position before layout
+ const panel = createStrategy27EventPanel(document, chartRoot, panelOptions(2, {
+ loadPosition: () => ({ left: 10000, top: 10000 }),
+ }));
+ t.after(() => panel.destroy());
+ const element = document.getElementById('jh-strategy27-event-panel');
+
+ // Then the designed 320 by 48 pre-layout bounds keep the panel on screen
+ assert.equal(element.offsetWidth, 0);
+ assert.equal(element.offsetHeight, 0);
+ assert.equal(element.style.left, '704px');
+ assert.equal(element.style.top, '720px');
+});
+
+test('user sees neutral facts without a directional color or an empty detail separator', (t) => {
+ // Given the event contains neutral facts and a force row without additional detail
+ const dom = loadFixtureDom('');
+ t.after(() => dom.window.close());
+ const { document } = dom.window;
+ const panel = createStrategy27EventPanel(document, document.querySelector('.chart-widget-root'), panelOptions(2));
+ t.after(() => panel.destroy());
+ const neutral = { ...annotation(), markerColor: null, candidateText: null, forceRows: [{ label: 'Trades', value: '0 trades', detail: null }] };
+
+ // When the neutral observation becomes the selected event
+ panel.upsert('neutral', neutral, 2000);
+ const detail = document.querySelector('[data-role="event-detail"]');
+ const row = document.querySelector('[data-event-id="neutral"]');
+
+ // Then neutral text remains readable and the event dot has no direction
+ assert.equal(detail.firstElementChild.firstElementChild.style.color, 'rgb(234, 236, 239)');
+ assert.equal([...detail.children].find(element => element.textContent.includes(neutral.summary)).lastElementChild.style.color, 'rgb(234, 236, 239)');
+ assert.equal(row.firstElementChild.style.background, 'transparent');
+ assert.match(detail.textContent, /0 trades/);
+ assert.doesNotMatch(detail.textContent, /0 trades｜/);
+});
+
+test('user retains the reported monitor stop after transport reconnects', (t) => {
+ // Given a terminal event explicitly reports that monitoring stopped
+ const dom = loadFixtureDom('');
+ t.after(() => dom.window.close());
+ const { document } = dom.window;
+ const panel = createStrategy27EventPanel(document, document.querySelector('.chart-widget-root'), panelOptions(2, { locale: 'en' }));
+ t.after(() => panel.destroy());
+ panel.upsert('stopped', annotation(), 3000);
+ panel.observeOrdinaryEvent({ triggered_at_ms: 1000, event_status: 'incomplete', close_reason: 'monitor_stopped' }, 3000);
+
+ // When the transport reconnects and existing observations become retained history
+ panel.setOrdinaryConnection('reconnecting');
+ panel.retainHistory();
+ panel.setOrdinaryConnection('connected');
+
+ // Then a connected transport does not claim the monitor has restarted
+ const monitoring = document.querySelector('[data-role="ordinary-monitoring-status"]');
+ assert.equal(monitoring.dataset.state, 'stopped');
+ assert.match(monitoring.textContent, /Monitoring stopped\. Retained records are historical\./);
+ assert.equal(document.querySelector('[data-role="ordinary-connection-status"]').textContent, 'Event data: Connected');
+ assert.equal(document.querySelector('[data-event-id="stopped"]').dataset.historical, 'true');
+});
+
+test('user keeps the selected event while collapsing the panel and changing language', (t) => {
+ // Given a selected event carries both supported localized copies
+ const dom = loadFixtureDom('');
+ t.after(() => dom.window.close());
+ const { document } = dom.window;
+ const panel = createStrategy27EventPanel(document, document.querySelector('.chart-widget-root'), panelOptions(2));
+ t.after(() => panel.destroy());
+ panel.upsert('selected', createLocalizedAnnotation(locale => ({ ...annotation(), title: locale === 'en' ? 'Order flow observation' : '订单流观察' }), 'zh-CN'), 2000);
+ document.querySelector('[data-event-id="selected"]').click();
+ const collapse = document.querySelector('[data-role="collapse"]');
+ const body = document.querySelector('[data-role="panel-body"]');
+
+ // When the user collapses the panel and switches its language
+ collapse.click();
+ panel.setLocale('en');
+
+ // Then the hidden body retains its selected record with the localized expand action
+ assert.equal(body.style.display, 'none');
+ assert.equal(collapse.textContent, 'Expand');
+ assert.match(document.querySelector('[data-role="event-detail"]').textContent, /Order flow observation/);
+ assert.equal(document.querySelector('[data-role="follow-latest"]').style.color, 'rgb(234, 236, 239)');
+ assert.equal(panel.size, 1);
+
+ // When the user expands the same panel
+ collapse.click();
+
+ // Then its record is visible again without replaying the event stream
+ assert.equal(body.style.display, 'block');
+ assert.equal(collapse.textContent, 'Collapse');
+ assert.equal(document.querySelector('[data-role="event-row"]').dataset.eventId, 'selected');
+});
+
+test('user does not move or persist the panel with a secondary-button drag', (t) => {
+ // Given the panel has a valid saved position and records persistence attempts
+ const dom = loadFixtureDom('');
+ t.after(() => dom.window.close());
+ const { document } = dom.window;
+ const saved = [];
+ const panel = createStrategy27EventPanel(document, document.querySelector('.chart-widget-root'), panelOptions(2, {
+ loadPosition: () => ({ left: 100, top: 120 }), savePosition: position => saved.push(position),
+ }));
+ t.after(() => panel.destroy());
+ const element = document.getElementById('jh-strategy27-event-panel');
+
+ // When the header receives a secondary-button drag gesture
+ element.querySelector('header').dispatchEvent(new dom.window.MouseEvent('mousedown', { bubbles: true, button: 2, clientX: 120, clientY: 140 }));
+ document.dispatchEvent(new dom.window.MouseEvent('mousemove', { bubbles: true, clientX: 400, clientY: 400 }));
+ document.dispatchEvent(new dom.window.MouseEvent('mouseup', { bubbles: true, button: 2 }));
+
+ // Then neither the panel coordinates nor persisted settings change
+ assert.equal(element.style.left, '100px');
+ assert.equal(element.style.top, '120px');
+ assert.deepEqual(saved, []);
+});
+
+for (const [label, update, expected] of [
+ ['unknown ordinary connection', panel => panel.setOrdinaryConnection('unknown'), 'Invalid ordinary connection state'],
+ ['unknown compound status', panel => panel.setCompoundStatus('Connected', 'unknown'), 'Strategy 27 compound panel status is invalid'],
+ ['non-text compound status', panel => panel.setCompoundStatus(null, 'normal'), 'Strategy 27 compound panel status is invalid'],
+]) {
+ test(`user rejects ${label} without changing the visible connection state`, (t) => {
+ // Given both panel streams have their original connection presentation
+ const dom = loadFixtureDom('');
+ t.after(() => dom.window.close());
+ const { document } = dom.window;
+ const panel = createStrategy27EventPanel(document, document.querySelector('.chart-widget-root'), panelOptions(2));
+ t.after(() => panel.destroy());
+ const before = document.querySelector('[data-role="panel-body"]').textContent;
+
+ // When a caller supplies the invalid connection update
+ const failure = captureStrategyError(() => update(panel));
+
+ // Then the update fails explicitly and existing visible state survives
+ assert.equal(failure.message, expected);
+ assert.equal(document.querySelector('[data-role="panel-body"]').textContent, before);
+ });
+}
diff --git a/test/dom/binance-strategy27-events/tradingview-compound-layer.test.js b/test/dom/binance-strategy27-events/tradingview-compound-layer.test.js
index 1e0f4fd..d09b082 100644
--- a/test/dom/binance-strategy27-events/tradingview-compound-layer.test.js
+++ b/test/dom/binance-strategy27-events/tradingview-compound-layer.test.js
@@ -48,11 +48,14 @@ function fixture({ bars = [[10, 1.25, 1.3, 1.2, 1.25]], beforeCreate, shiftSecon
return { chart, shapes, listeners, created, removed, layer: (maxCandidates = 80) => createTradingViewCompoundLayer({ chart }, { maxCandidates, candleWaitMs: 1 }) };
}
-test('native compound arrows are larger, centered outside the candle and own a separate short label', async () => {
+test('user observes that native compound arrows are larger, centered outside the candle and own a separate short label', async () => {
+ // Given a native chart and compound candidate annotations
const f = fixture();
+ // When f.layer processes the configured inputs
const layer = f.layer();
await layer.renderCandidate('high', annotation(), 11000);
await layer.renderCandidate('low', annotation({ markerShape: 'arrow_up', markerLabel: '候选低', markerColor: '#087F5B' }), 11000);
+ // Then user observes that native compound arrows are larger, centered outside the candle and own a separate short label
assert.equal(layer.size, 2);
assert.equal(f.shapes.size, 5);
assert.deepEqual(f.created.map((item) => item.point), [
@@ -74,13 +77,16 @@ test('native compound arrows are larger, centered outside the candle and own a s
assert.equal(f.removed.length, 4);
});
-test('same-time rules own independent fixed slots and eviction never moves surviving entities', async () => {
+test('user observes that same-time rules own independent fixed slots and eviction never moves surviving entities', async () => {
+ // Given a native chart and compound candidate annotations
const f = fixture();
+ // When f.layer processes the configured inputs
const layer = f.layer();
await layer.renderCandidate('impact', annotation(), 11000);
await layer.renderCandidate('passive', annotation(), 11000);
await layer.renderCandidate('impact', annotation(), 11000);
const survivor = f.created.slice(2).map((item) => ({ ...item.point }));
+ // Then user observes that same-time rules own independent fixed slots and eviction never moves surviving entities
assert.deepEqual(survivor, [{ time: 10, price: 1.39 }, { time: 10, price: 1.43 }]);
layer.remove('impact');
await layer.renderCandidate('reinforcement', annotation(), 11000);
@@ -91,20 +97,26 @@ test('same-time rules own independent fixed slots and eviction never moves survi
assert.deepEqual(f.removed, ['owned-1', 'owned-2']);
});
-test('different no-trade decision seconds sharing a prior candle receive distinct slots', async () => {
+test('user observes that different no-trade decision seconds sharing a prior candle receive distinct slots', async () => {
+ // Given a native chart and compound candidate annotations
const f = fixture();
+ // When f.layer processes the configured inputs
const layer = f.layer();
await layer.renderCandidate('second-11', annotation({ markerTime: 11 }), 12000);
await layer.renderCandidate('second-12', annotation({ markerTime: 12 }), 13000);
+ // Then user observes that different no-trade decision seconds sharing a prior candle receive distinct slots
assert.deepEqual(f.created.map((item) => item.point.time), [10, 10, 10, 10]);
assert.deepEqual(f.created.filter((item) => item.options.shape === 'icon').map((item) => item.point.price), [1.326, 1.39]);
assert.equal(f.listeners.size, 0);
});
-test('remove cancels a pending candle wait without waiting for its deadline', async () => {
+test('user observes that remove cancels a pending candle wait without waiting for its deadline', async () => {
+ // Given a native chart and compound candidate annotations
const f = fixture({ bars: [] });
+ // When f.layer processes the configured inputs
const layer = f.layer();
const result = layer.renderCandidate('waiting', annotation(), 11000);
+ // Then user observes that remove cancels a pending candle wait without waiting for its deadline
assert.equal(f.listeners.size, 1);
layer.remove('waiting');
assert.equal(await result, false);
@@ -112,8 +124,10 @@ test('remove cancels a pending candle wait without waiting for its deadline', as
assert.equal(f.created.length, 0);
});
-test('clear removes a native icon that finishes creation late and never creates its label', async () => {
+test('user observes that clear removes a native icon that finishes creation late and never creates its label', async () => {
+ // Given a native chart and compound candidate annotations
const entered = deferred();
+ // When deferred processes the configured inputs
const release = deferred();
const f = fixture({ beforeCreate: async () => { entered.resolve(); await release.promise; } });
const layer = f.layer();
@@ -121,20 +135,24 @@ test('clear removes a native icon that finishes creation late and never creates
await entered.promise;
layer.clear();
release.resolve();
+ // Then user observes that clear removes a native icon that finishes creation late and never creates its label
assert.equal(await result, false);
assert.equal(layer.size, 0);
assert.deepEqual(f.removed, ['owned-1']);
assert.deepEqual([...f.shapes.keys()], ['user-owned']);
});
-test('remove cancels a pending label and removes each part of the pair exactly once', async () => {
+test('user observes that remove cancels a pending label and removes each part of the pair exactly once', async () => {
+ // Given a native chart and compound candidate annotations
const entered = deferred();
+ // When deferred processes the configured inputs
const release = deferred();
const f = fixture({ beforeCreate: async (count) => { if (count === 2) { entered.resolve(); await release.promise; } } });
const layer = f.layer();
const result = layer.renderCandidate('late-label', annotation(), 11000);
await entered.promise;
layer.remove('late-label');
+ // Then user observes that remove cancels a pending label and removes each part of the pair exactly once
assert.deepEqual(f.removed, ['owned-1']);
release.resolve();
assert.equal(await result, false);
@@ -142,30 +160,40 @@ test('remove cancels a pending label and removes each part of the pair exactly o
assert.deepEqual([...f.shapes.keys()], ['user-owned']);
});
-test('partial label failure rolls back the already-created icon', async () => {
+test('user observes that partial label failure rolls back the already-created icon', async () => {
+ // Given a native chart and compound candidate annotations
const f = fixture({ beforeCreate: (count) => { if (count === 2) throw new Error('fixture label failure'); } });
+ // When f.layer processes the configured inputs
const layer = f.layer();
+ // Then user observes that partial label failure rolls back the already-created icon
await assert.rejects(layer.renderCandidate('partial', annotation(), 11000), /fixture label failure/);
assert.deepEqual(f.removed, ['owned-1']);
assert.equal(layer.size, 0);
assert.deepEqual([...f.shapes.keys()], ['user-owned']);
});
-test('shifted times and unsupported drawing properties roll back their own entity', async () => {
- for (const options of [{ shiftSeconds: 1 }, { wrongProperties: true }]) {
+for (const options of [{ shiftSeconds: 1 }, { wrongProperties: true }]) {
+ test(`user observes that shifted times and unsupported drawing properties roll back their own entity (options=${JSON.stringify(options)})`, async () => {
+ // Given a native chart and compound candidate annotations
const f = fixture(options);
+ // When f.layer processes the configured inputs
const layer = f.layer();
+ // Then user observes that shifted times and unsupported drawing properties roll back their own entity (options=the selected case)
await assert.rejects(layer.renderCandidate('bad', annotation(), 11000), options.shiftSeconds ? /time alignment failed/ : /drawing properties/);
assert.equal(layer.size, 0);
assert.deepEqual(f.removed, ['owned-1']);
assert.deepEqual([...f.shapes.keys()], ['user-owned']);
- }
-});
-test('cleanup attempts both owned entities and reports failures without touching user drawings', async () => {
+ });
+}
+
+test('user observes that cleanup attempts both owned entities and reports failures without touching user drawings', async () => {
+ // Given a native chart and compound candidate annotations
const f = fixture({ removeError: new Error('fixture removal failure') });
+ // When f.layer processes the configured inputs
const layer = f.layer();
await layer.renderCandidate('high', annotation(), 11000);
+ // Then user observes that cleanup attempts both owned entities and reports failures without touching user drawings
assert.throws(() => layer.clear(), (error) => error instanceof AggregateError && error.errors.length === 2);
assert.equal(layer.size, 0);
assert.deepEqual(f.removed, ['owned-1', 'owned-2']);
@@ -174,14 +202,17 @@ test('cleanup attempts both owned entities and reports failures without touching
assert.equal(f.removed.length, 2, 'unknown removals are not automatically retried');
});
-test('80 compound pairs plus 80 ordinary markers have a strict 240-entity budget', async () => {
+test('user observes that 80 compound pairs plus 80 ordinary markers have a strict 240-entity budget', async () => {
+ // Given a native chart and compound candidate annotations
const f = fixture();
const ordinary = createTradingViewEventLayer({ chart: f.chart }, { maxEvents: 80, maxAgeMs: 7200000 });
+ // When f.layer processes the configured inputs
const layer = f.layer();
for (let i = 0; i < 80; i += 1) {
await ordinary.renderOpened(`ordinary-${i}`, annotation(), 11000);
await layer.renderCandidate(`compound-${i}`, annotation(), 11000);
}
+ // Then user observes that 80 compound pairs plus 80 ordinary markers have a strict 240-entity budget
assert.equal(f.shapes.size, 241);
assert.equal(layer.size, 80);
assert.equal(ordinary.size, 80);
@@ -193,8 +224,10 @@ test('80 compound pairs plus 80 ordinary markers have a strict 240-entity budget
assert.deepEqual([...f.shapes.keys()], ['user-owned']);
});
-test('compound reconciliation restores only missing parts in their original slots', async () => {
+test('user observes that compound reconciliation restores only missing parts in their original slots', async () => {
+ // Given a native chart and compound candidate annotations
const f = fixture();
+ // When f.layer processes the configured inputs
const layer = f.layer();
await layer.renderCandidate('a', annotation(), 11000);
await layer.renderCandidate('b', annotation(), 11000);
@@ -202,6 +235,7 @@ test('compound reconciliation restores only missing parts in their original slot
f.shapes.delete('owned-3');
f.shapes.delete('owned-4');
await layer.reconcile();
+ // Then user observes that compound reconciliation restores only missing parts in their original slots
assert.equal(layer.size, 2);
assert.equal(f.created.length, 7);
assert.equal(f.shapes.has('owned-2'), true);
@@ -214,23 +248,29 @@ test('compound reconciliation restores only missing parts in their original slot
assert.deepEqual([...f.shapes.keys()], ['user-owned']);
});
-test('a repeated candidate restores externally removed entities', async () => {
+test('user observes that a repeated candidate restores externally removed entities', async () => {
+ // Given a native chart and compound candidate annotations
const f = fixture();
+ // When f.layer processes the configured inputs
const layer = f.layer();
await layer.renderCandidate('a', annotation(), 11000);
f.shapes.delete('owned-1');
f.shapes.delete('owned-2');
+ // Then user observes that a repeated candidate restores externally removed entities
assert.equal(await layer.renderCandidate('a', annotation(), 11000), true);
assert.equal(f.created.length, 4);
assert.equal(layer.size, 1);
assert.equal(f.shapes.size, 3);
});
-test('suspension preserves completed pairs and cancels a pending candle wait', async () => {
+test('user observes that suspension preserves completed pairs and cancels a pending candle wait', async () => {
+ // Given a native chart and compound candidate annotations
const f = fixture();
const layer = createTradingViewCompoundLayer({ chart: f.chart }, { maxCandidates: 80, candleWaitMs: 3000 });
+ // When layer.renderCandidate processes the configured inputs
await layer.renderCandidate('verified', annotation(), 11000);
const pending = layer.renderCandidate('waiting', annotation({ markerTime: 11 }), 12000);
+ // Then user observes that suspension preserves completed pairs and cancels a pending candle wait
assert.equal(f.listeners.size, 1);
layer.suspend();
assert.equal(await pending, false);
@@ -246,8 +286,10 @@ test('suspension preserves completed pairs and cancels a pending candle wait', a
});
for (const phase of ['icon', 'label', 'repair']) {
- test(`suspension removes late ${phase} entities without removing verified history`, async () => {
+ test(`user observes that suspension removes late ${phase} entities without removing verified history`, async () => {
+ // Given a native chart and compound candidate annotations
const entered = deferred();
+ // When deferred processes the configured inputs
const release = deferred();
const blockedCreate = phase === 'label' ? 4 : 3;
const f = fixture({ beforeCreate: async (count) => {
@@ -261,6 +303,7 @@ for (const phase of ['icon', 'label', 'repair']) {
layer.suspend();
release.resolve();
await pending;
+ // Then user observes that suspension removes late the selected case entities without removing verified history
assert.deepEqual([...f.shapes.keys()], phase === 'repair' ? ['user-owned', 'owned-2'] : ['user-owned', 'owned-1', 'owned-2']);
assert.deepEqual(f.removed, phase === 'label' ? ['owned-3', 'owned-4'] : ['owned-3']);
assert.equal(layer.size, 1);
@@ -271,9 +314,11 @@ for (const phase of ['icon', 'label', 'repair']) {
});
}
-test('compound timer and replay share a single repair and discard late parts after invalidation', async () => {
- for (const action of ['retain', 'clear', 'remove', 'interval', 'symbol']) {
+for (const action of ['retain', 'clear', 'remove', 'interval', 'symbol']) {
+ test(`user observes that compound timer and replay share a single repair and discard late parts after invalidation (action=${JSON.stringify(action)})`, async () => {
+ // Given a native chart and compound candidate annotations
const entered = deferred();
+ // When deferred processes the configured inputs
const release = deferred();
const f = fixture({ beforeCreate: async (count) => { if (count === 3) { entered.resolve(); await release.promise; } } });
const layer = f.layer();
@@ -288,6 +333,7 @@ test('compound timer and replay share a single repair and discard late parts aft
if (action === 'interval') f.chart.resolution = () => '1';
if (action === 'symbol') f.chart.symbol = () => 'BTCUSDT';
release.resolve();
+ // Then user observes that compound timer and replay share a single repair and discard late parts after invalidation (action=the selected case)
assert.equal(await replay, action === 'retain', action);
await Promise.all([repair, anotherTick]);
assert.equal(f.created.length, 3, action);
@@ -296,14 +342,18 @@ test('compound timer and replay share a single repair and discard late parts aft
layer.clear();
await layer.reconcile();
assert.deepEqual([...f.shapes.keys()], ['user-owned']);
- }
-});
-test('cleanup skips evicted compound parts and still reports a live part removal failure', async () => {
+ });
+}
+
+test('user observes that cleanup skips evicted compound parts and still reports a live part removal failure', async () => {
+ // Given a native chart and compound candidate annotations
const f = fixture({ removeError: new Error('fixture removal failure') });
+ // When f.layer processes the configured inputs
const layer = f.layer();
await layer.renderCandidate('a', annotation(), 11000);
f.shapes.delete('owned-1');
+ // Then user observes that cleanup skips evicted compound parts and still reports a live part removal failure
assert.throws(() => layer.clear(), (error) => error instanceof AggregateError && error.errors.length === 1);
assert.deepEqual(f.removed, ['owned-2']);
assert.equal(layer.size, 0);
@@ -312,7 +362,8 @@ test('cleanup skips evicted compound parts and still reports a live part removal
});
for (const phase of ['settled', 'creating', 'restoring']) {
- test(`locale changes preserve compound entity ownership while ${phase}`, async () => {
+ test(`user observes that locale changes preserve compound entity ownership while ${phase}`, async () => {
+ // Given a native chart and compound candidate annotations
const gate = deferred();
let blocked = false;
const f = fixture({ beforeCreate: (count) => {
@@ -321,6 +372,7 @@ for (const phase of ['settled', 'creating', 'restoring']) {
return gate.promise;
}
} });
+ // When f.layer processes the configured inputs
const layer = f.layer();
let pending = layer.renderCandidate('high', annotation(), 11000);
if (phase !== 'creating') await pending;
@@ -335,6 +387,7 @@ for (const phase of ['settled', 'creating', 'restoring']) {
layer.setLocale('en');
gate.resolve();
await pending;
+ // Then user observes that locale changes preserve compound entity ownership while the selected case
assert.equal(f.shapes.get(phase === 'restoring' ? 'owned-3' : 'owned-2').getProperties().text, 'High candidate');
assert.equal(f.shapes.has('owned-1'), true);
assert.deepEqual(f.removed, []);
diff --git a/test/dom/binance-strategy27-events/tradingview-event-layer.test.js b/test/dom/binance-strategy27-events/tradingview-event-layer.test.js
index 7695f1a..9b6ad6a 100644
--- a/test/dom/binance-strategy27-events/tradingview-event-layer.test.js
+++ b/test/dom/binance-strategy27-events/tradingview-event-layer.test.js
@@ -2,10 +2,14 @@ import assert from 'node:assert/strict';
import test from 'node:test';
import { loadFixtureDom } from '../../helpers/dom.js';
+import { captureStrategyError, createStrategyShapeBoundary } from '../../helpers/strategy-migration-boundaries.js';
import {
+ createAlignedShape,
createTradingViewEventLayer,
+ createTradingViewMarkerPlacement,
findStrategy27ChartRoot,
findStrategy27ChartTarget as resolveStrategy27ChartTarget,
+ readLiveShapeIds,
} from '../../../src/binance-strategy27-events/dom/tradingview-event-layer.js';
function findStrategy27ChartTarget(document, symbol) {
@@ -19,17 +23,21 @@ function createChartDom({
deferredCreate = false,
candle = [10, 1.25, 1.3, 1.2, 1.25],
previousCandle = null,
+ priceToCoordinate = price => 2_000 - (price * 1_000),
+ coordinateToPrice = coordinate => (2_000 - coordinate) / 1_000,
} = {}) {
const dom = loadFixtureDom('
');
const shapes = new Map();
const removed = [];
const dataUpdatedListeners = [];
let currentCandle = candle;
+ let currentResolution = resolution;
+ let currentSymbol = symbol;
let nextId = 1;
let releaseCreate = null;
const chart = {
- resolution: () => resolution,
- symbol: () => symbol,
+ resolution: () => currentResolution,
+ symbol: () => currentSymbol,
async createShape(point, properties) {
if (deferredCreate) await new Promise((resolve) => { releaseCreate = resolve; });
const id = `shape-${nextId++}`;
@@ -78,8 +86,8 @@ function createChartDom({
}),
firstValue: () => 1,
priceScale: () => ({
- priceToCoordinate: (price) => 2_000 - (price * 1_000),
- coordinateToPrice: (coordinate) => (2_000 - coordinate) / 1_000,
+ priceToCoordinate,
+ coordinateToPrice,
}),
}),
}),
@@ -96,6 +104,8 @@ function createChartDom({
removed,
releaseCreate: () => releaseCreate(),
setCandle: (value) => { currentCandle = value; },
+ setResolution: (value) => { currentResolution = value; },
+ setSymbol: (value) => { currentSymbol = value; },
fireDataUpdated: () => {
for (const { listener } of [...dataUpdatedListeners]) listener();
},
@@ -115,9 +125,12 @@ function annotation(overrides = {}) {
};
}
-test('requires an exact matching one-second TradingView chart', () => {
+test('user requires an exact matching one-second TradingView chart', () => {
+ // Given a native chart and ordinary event annotations
const { dom } = createChartDom();
+ // When findStrategy27ChartTarget processes the configured inputs
const target = findStrategy27ChartTarget(dom.window.document, 'BTRUSDT');
+ // Then user requires an exact matching one-second TradingView chart
assert.equal(target.routeSymbol, 'BTRUSDT');
assert.equal(target.resolution, '1S');
@@ -133,12 +146,15 @@ test('requires an exact matching one-second TradingView chart', () => {
);
});
-test('one event owns one marker across its complete lifecycle', async () => {
+test('user observes that one event owns one marker across its complete lifecycle', async () => {
+ // Given a native chart and ordinary event annotations
const { dom, shapes, removed } = createChartDom();
+ // When findStrategy27ChartTarget processes the configured inputs
const target = findStrategy27ChartTarget(dom.window.document, 'BTRUSDT');
const layer = createTradingViewEventLayer(target, { maxEvents: 2, maxAgeMs: 60_000 });
await layer.renderOpened('event-a', annotation(), 10_000);
+ // Then user observes that one event owns one marker across its complete lifecycle
assert.equal(shapes.size, 1);
await layer.renderUpdated('event-a', annotation(), 11_000);
assert.equal(shapes.size, 1);
@@ -160,8 +176,10 @@ test('one event owns one marker across its complete lifecycle', async () => {
assert.equal(removed.length, 2);
});
-test('places red and green directional arrows eight pixels outside the matching candle', async () => {
+test('user sees red and green directional arrows eight pixels outside the matching candle', async () => {
+ // Given a native chart and ordinary event annotations
const { dom, shapes } = createChartDom();
+ // When findStrategy27ChartTarget processes the configured inputs
const target = findStrategy27ChartTarget(dom.window.document, 'BTRUSDT');
const layer = createTradingViewEventLayer(target, { maxEvents: 3, maxAgeMs: 60_000 });
@@ -172,12 +190,15 @@ test('places red and green directional arrows eight pixels outside the matching
markerPrice: 0.01,
}), 10_001);
const [up, down] = [...shapes.values()];
+ // Then user sees red and green directional arrows eight pixels outside the matching candle
assert.equal(up.getPoints()[0].price, 1.192);
assert.equal(down.getPoints()[0].price, 1.308);
});
-test('keeps the first event marker immutable when later updates change direction', async () => {
+test('user keeps the first event marker immutable when later updates change direction', async () => {
+ // Given a native chart and ordinary event annotations
const { dom, shapes, removed } = createChartDom();
+ // When findStrategy27ChartTarget processes the configured inputs
const target = findStrategy27ChartTarget(dom.window.document, 'BTRUSDT');
const layer = createTradingViewEventLayer(target, { maxEvents: 2, maxAgeMs: 60_000 });
@@ -188,6 +209,7 @@ test('keeps the first event marker immutable when later updates change direction
markerColor: '#F6465D',
}), 11_000);
+ // Then user keeps the first event marker immutable when later updates change direction
assert.equal(shapes.size, 1);
assert.deepEqual(removed, []);
assert.deepEqual([...shapes.keys()], [originalId]);
@@ -196,8 +218,10 @@ test('keeps the first event marker immutable when later updates change direction
assert.equal(marker.getPoints()[0].price, 1.192);
});
-test('waits for the matching candle data update before placing a directional marker', async () => {
+test('user waits for the matching candle data update before placing a directional marker', async () => {
+ // Given a native chart and ordinary event annotations
const fixture = createChartDom({ candle: null });
+ // When findStrategy27ChartTarget processes the configured inputs
const target = findStrategy27ChartTarget(fixture.dom.window.document, 'BTRUSDT');
const layer = createTradingViewEventLayer(target, {
maxEvents: 2,
@@ -207,6 +231,7 @@ test('waits for the matching candle data update before placing a directional mar
const renderPromise = layer.renderOpened('event-a', annotation(), 10_000);
await Promise.resolve();
+ // Then user waits for the matching candle data update before placing a directional marker
assert.equal(fixture.shapes.size, 0);
assert.equal(fixture.dataUpdatedListenerCount, 1);
@@ -219,8 +244,10 @@ test('waits for the matching candle data update before placing a directional mar
assert.equal([...fixture.shapes.values()][0].getPoints()[0].price, 1.192);
});
-test('does not create a marker for a neutral observation', async () => {
+test('user does not create a marker for a neutral observation', async () => {
+ // Given a native chart and ordinary event annotations
const fixture = createChartDom({ candle: null });
+ // When findStrategy27ChartTarget processes the configured inputs
const target = findStrategy27ChartTarget(fixture.dom.window.document, 'BTRUSDT');
const layer = createTradingViewEventLayer(target, {
maxEvents: 2,
@@ -228,16 +255,20 @@ test('does not create a marker for a neutral observation', async () => {
candleWaitMs: 50,
});
- assert.equal(await layer.renderOpened('event-a', annotation({
+ const observedResult = await layer.renderOpened('event-a', annotation({
markerShape: null,
markerColor: null,
- }), 10_000), true);
+ }), 10_000);
+ // Then user does not create a marker for a neutral observation
+ assert.equal(observedResult, true);
assert.equal(fixture.shapes.size, 0);
assert.equal(fixture.dataUpdatedListenerCount, 0);
});
-test('rejects a directional marker when its matching candle misses the bounded wait', async () => {
+test('user rejects a directional marker when its matching candle misses the bounded wait', async () => {
+ // Given a native chart and ordinary event annotations
const { dom } = createChartDom({ candle: null });
+ // When findStrategy27ChartTarget processes the configured inputs
const target = findStrategy27ChartTarget(dom.window.document, 'BTRUSDT');
const layer = createTradingViewEventLayer(target, {
maxEvents: 2,
@@ -245,17 +276,21 @@ test('rejects a directional marker when its matching candle misses the bounded w
candleWaitMs: 5,
});
+ const observedResult = layer.renderOpened('event-a', annotation(), 10_000);
+ // Then user rejects a directional marker when its matching candle misses the bounded wait
await assert.rejects(
- layer.renderOpened('event-a', annotation(), 10_000),
+ observedResult,
/candle did not arrive within 5 ms for 10/,
);
});
-test('does not anchor a neutral observation to a previous candle', async () => {
+test('user does not anchor a neutral observation to a previous candle', async () => {
+ // Given a native chart and ordinary event annotations
const fixture = createChartDom({
candle: null,
previousCandle: [9, 1.24, 1.28, 1.18, 1.23],
});
+ // When findStrategy27ChartTarget processes the configured inputs
const target = findStrategy27ChartTarget(fixture.dom.window.document, 'BTRUSDT');
const layer = createTradingViewEventLayer(target, {
maxEvents: 2,
@@ -263,20 +298,24 @@ test('does not anchor a neutral observation to a previous candle', async () => {
candleWaitMs: 5,
});
- assert.equal(await layer.renderOpened('event-a', annotation({
+ const observedResult = await layer.renderOpened('event-a', annotation({
markerShape: null,
markerColor: null,
- }), 10_000), true);
+ }), 10_000);
+ // Then user does not anchor a neutral observation to a previous candle
+ assert.equal(observedResult, true);
assert.equal(fixture.shapes.size, 0);
assert.equal(fixture.dataUpdatedListenerCount, 0);
});
-test('places a directional event outside the latest prior candle when its exact second has no trade', async () => {
+test('user sees a directional event outside the latest prior candle when its exact second has no trade', async () => {
+ // Given a native chart and ordinary event annotations
const fixture = createChartDom({
candle: null,
previousCandle: [9, 1.24, 1.28, 1.18, 1.23],
});
+ // When findStrategy27ChartTarget processes the configured inputs
const target = findStrategy27ChartTarget(fixture.dom.window.document, 'BTRUSDT');
const layer = createTradingViewEventLayer(target, {
maxEvents: 2,
@@ -284,15 +323,19 @@ test('places a directional event outside the latest prior candle when its exact
candleWaitMs: 5,
});
- assert.equal(await layer.renderOpened('event-a', annotation(), 10_000), true);
+ const observedResult = await layer.renderOpened('event-a', annotation(), 10_000);
+ // Then user sees a directional event outside the latest prior candle when its exact second has no trade
+ assert.equal(observedResult, true);
const marker = [...fixture.shapes.values()][0];
assert.deepEqual(marker.getPoints(), [{ time: 9, price: 1.172 }]);
assert.equal(fixture.dataUpdatedListenerCount, 0);
});
-test('clear cancels a pending candle wait without creating a late marker', async () => {
+test('user observes that clear cancels a pending candle wait without creating a late marker', async () => {
+ // Given a native chart and ordinary event annotations
const fixture = createChartDom({ candle: null });
+ // When findStrategy27ChartTarget processes the configured inputs
const target = findStrategy27ChartTarget(fixture.dom.window.document, 'BTRUSDT');
const layer = createTradingViewEventLayer(target, {
maxEvents: 2,
@@ -304,6 +347,7 @@ test('clear cancels a pending candle wait without creating a late marker', async
await Promise.resolve();
layer.clear();
+ // Then user observes that clear cancels a pending candle wait without creating a late marker
assert.equal(await renderPromise, false);
assert.equal(fixture.dataUpdatedListenerCount, 0);
fixture.setCandle([10, 1.25, 1.3, 1.2, 1.25]);
@@ -311,26 +355,32 @@ test('clear cancels a pending candle wait without creating a late marker', async
assert.equal(fixture.shapes.size, 0);
});
-test('removes a shifted entity and reports chart alignment failure', async () => {
+test('user removes a shifted entity and reports chart alignment failure', async () => {
+ // Given a native chart and ordinary event annotations
const { dom, shapes, removed } = createChartDom({ shiftSeconds: -1 });
+ // When findStrategy27ChartTarget processes the configured inputs
const target = findStrategy27ChartTarget(dom.window.document, 'BTRUSDT');
const layer = createTradingViewEventLayer(target, { maxEvents: 2, maxAgeMs: 60_000 });
+ const observedResult = layer.renderOpened('event-a', annotation(), 10_000);
+ // Then user removes a shifted entity and reports chart alignment failure
await assert.rejects(
- layer.renderOpened('event-a', annotation(), 10_000),
+ observedResult,
/chart time alignment failed: expected 10, received 9 \(point count 1\)/,
);
assert.equal(shapes.size, 0);
assert.equal(removed.length, 1);
});
-test('clear removes a marker whose asynchronous creation finishes late', async () => {
+test('user observes that clear removes a marker whose asynchronous creation finishes late', async () => {
+ // Given a native chart and ordinary event annotations
const {
dom,
shapes,
removed,
releaseCreate,
} = createChartDom({ deferredCreate: true });
+ // When findStrategy27ChartTarget processes the configured inputs
const target = findStrategy27ChartTarget(dom.window.document, 'BTRUSDT');
const layer = createTradingViewEventLayer(target, { maxEvents: 2, maxAgeMs: 60_000 });
@@ -339,19 +389,23 @@ test('clear removes a marker whose asynchronous creation finishes late', async (
layer.clear();
releaseCreate();
+ // Then user observes that clear removes a marker whose asynchronous creation finishes late
assert.equal(await renderPromise, false);
assert.equal(layer.size, 0);
assert.equal(shapes.size, 0);
assert.equal(removed.length, 1);
});
-test('an update restores an externally evicted marker with its original immutable presentation', async () => {
+test('user observes that an update restores an externally evicted marker with its original immutable presentation', async () => {
+ // Given a native chart and ordinary event annotations
const f = createChartDom();
const layer = createTradingViewEventLayer({ chart: f.chart }, { maxEvents: 2, maxAgeMs: 60000 });
+ // When layer.renderOpened processes the configured inputs
await layer.renderOpened('a', annotation(), 10000);
const [oldId] = f.shapes.keys();
const point = f.shapes.get(oldId).getPoints();
f.shapes.delete(oldId);
+ // Then user observes that an update restores an externally evicted marker with its original immutable presentation
assert.equal(await layer.renderUpdated('a', annotation({ markerShape: 'arrow_down', markerColor: '#F6465D' }), 11000), true);
assert.equal(f.shapes.size, 1);
const [id, shape] = [...f.shapes][0];
@@ -363,13 +417,16 @@ test('an update restores an externally evicted marker with its original immutabl
assert.deepEqual(f.removed, []);
});
-test('reconciliation restores missing ordinary markers without an event and never revives a cleared record', async () => {
+test('user observes that reconciliation restores missing ordinary markers without an event and never revives a cleared record', async () => {
+ // Given a native chart and ordinary event annotations
const f = createChartDom();
const layer = createTradingViewEventLayer({ chart: f.chart }, { maxEvents: 2, maxAgeMs: 60000 });
+ // When f.shapes.set processes the configured inputs
f.shapes.set('foreign', {});
await layer.renderOpened('a', annotation(), 10000);
f.shapes.delete('shape-1');
await layer.reconcile();
+ // Then user observes that reconciliation restores missing ordinary markers without an event and never revives a cleared record
assert.deepEqual([...f.shapes.keys()], ['foreign', 'shape-2']);
await layer.reconcile();
assert.deepEqual([...f.shapes.keys()], ['foreign', 'shape-2']);
@@ -381,10 +438,12 @@ test('reconciliation restores missing ordinary markers without an event and neve
assert.equal(layer.size, 0);
});
-test('ordinary timer and gateway repair share a single creation and cancel stale results', async () => {
- for (const action of ['retain', 'clear', 'remove', 'expire', 'interval', 'symbol', 'suspend']) {
+for (const action of ['retain', 'clear', 'remove', 'expire', 'interval', 'symbol', 'suspend']) {
+ test(`user observes that ordinary timer and gateway repair share a single creation and cancel stale results (action=${JSON.stringify(action)})`, async () => {
+ // Given a native chart and ordinary event annotations
const f = createChartDom();
const layer = createTradingViewEventLayer({ chart: f.chart }, { maxEvents: 2, maxAgeMs: 60000 });
+ // When layer.renderOpened processes the configured inputs
await layer.renderOpened('a', annotation(), 10000);
f.shapes.delete('shape-1');
const entered = Promise.withResolvers();
@@ -408,6 +467,7 @@ test('ordinary timer and gateway repair share a single creation and cancel stale
if (action === 'interval') f.chart.resolution = () => '1';
if (action === 'symbol') f.chart.symbol = () => 'BTCUSDT';
release.resolve();
+ // Then user observes that ordinary timer and gateway repair share a single creation and cancel stale results (action=the selected case)
assert.equal(await update, action === 'retain', action);
await Promise.all([repair, anotherTick]);
assert.equal(creates, 1, action);
@@ -416,12 +476,15 @@ test('ordinary timer and gateway repair share a single creation and cancel stale
layer.clear();
await layer.reconcile();
assert.equal(f.shapes.size, 0);
- }
-});
-test('suspension retains existing markers, cancels late first creation and still permits expiry', async () => {
+ });
+}
+
+test('user observes that suspension retains existing markers, cancels late first creation and still permits expiry', async () => {
+ // Given a native chart and ordinary event annotations
const f = createChartDom();
const layer = createTradingViewEventLayer({ chart: f.chart }, { maxEvents: 3, maxAgeMs: 60000 });
+ // When layer.renderOpened processes the configured inputs
await layer.renderOpened('a', annotation(), 10000);
const entered = Promise.withResolvers();
const release = Promise.withResolvers();
@@ -431,6 +494,7 @@ test('suspension retains existing markers, cancels late first creation and still
await entered.promise;
layer.suspend();
release.resolve();
+ // Then user observes that suspension retains existing markers, cancels late first creation and still permits expiry
assert.equal(await pending, false);
assert.deepEqual([...f.shapes.keys()], ['shape-1']);
assert.equal(layer.size, 1);
@@ -441,3 +505,375 @@ test('suspension retains existing markers, cancels late first creation and still
assert.equal(layer.size, 0);
assert.equal(f.shapes.size, 0);
});
+
+test('user observes native chart fixture coordinates, shape identity and listener ownership', async (t) => {
+ // Given the chart fixture exposes unmodified host data and coordinate operations
+ const malformedCandle = { incomplete: true };
+ const fixture = createChartDom({ priceToCoordinate: price => price * 2, coordinateToPrice: coordinate => coordinate / 2 });
+ t.after(() => fixture.dom.window.close());
+ const model = fixture.chart._chartWidget.model().model();
+ const series = model.mainSeries();
+ const notifications = [];
+ const owner = {};
+ const listener = () => notifications.push('update');
+ series.dataUpdated().subscribe(owner, listener);
+ const point = { time: 10, price: 1.25 };
+
+ // When native shape creation, data delivery, and removal are exercised directly
+ const id = await fixture.chart.createShape(point, { shape: 'arrow_up' });
+ const shape = fixture.chart.getShapeById(id);
+ fixture.setCandle(malformedCandle);
+ fixture.setSymbol('ETHUSDT');
+ fixture.setResolution('5');
+ fixture.fireDataUpdated();
+ series.dataUpdated().unsubscribe(owner, listener);
+ fixture.fireDataUpdated();
+ const listed = fixture.chart.getAllShapes();
+ fixture.chart.removeEntity(id);
+
+ // Then the boundary preserves raw data, exact operations and independent subscription cleanup
+ assert.equal(id, 'shape-1');
+ assert.deepEqual(shape.getPoints(), [point]);
+ assert.equal(fixture.chart.getSeries().data().valueAt(5), malformedCandle);
+ assert.equal(series.priceScale().priceToCoordinate(1.25), 2.5);
+ assert.equal(series.priceScale().coordinateToPrice(2.5), 1.25);
+ assert.equal(fixture.chart.symbol(), 'ETHUSDT');
+ assert.equal(fixture.chart.resolution(), '5');
+ assert.deepEqual(notifications, ['update']);
+ assert.equal(fixture.dataUpdatedListenerCount, 0);
+ assert.deepEqual(listed, [{ id: 'shape-1' }]);
+ assert.deepEqual(fixture.removed, ['shape-1']);
+ assert.deepEqual(fixture.chart.getAllShapes(), []);
+});
+
+for (const [label, markup] of [
+ ['missing chart', ''],
+ ['hidden chart', ''],
+ ['missing frame', ''],
+ ['hidden frame', ''],
+ ['uninitialized frame API', ''],
+]) {
+ test(`user waits for the ${label} before binding ordinary markers`, (t) => {
+ // Given the native chart is still absent or has not exposed its required frame
+ const dom = loadFixtureDom(markup);
+ t.after(() => dom.window.close());
+
+ // When the current visible chart is resolved
+ const target = findStrategy27ChartTarget(dom.window.document, 'BTRUSDT');
+
+ // Then no chart target is invented during host initialization
+ assert.equal(target, null);
+ });
+}
+
+for (const [label, markup, expected] of [
+ ['roots', '', 'Visible Strategy 27 chart root count is invalid: 2'],
+ ['frames', '', 'Visible Strategy 27 chart frame count is invalid: 2'],
+]) {
+ test(`user rejects ambiguous visible chart ${label}`, (t) => {
+ // Given multiple visible native containers could receive the marker
+ const dom = loadFixtureDom(markup);
+ t.after(() => dom.window.close());
+
+ // When the route attempts to bind its current TradingView chart
+ const failure = captureStrategyError(() => findStrategy27ChartTarget(dom.window.document, 'BTRUSDT'));
+
+ // Then ambiguity is explicit and no arbitrary container is chosen
+ assert.equal(failure.message, expected);
+ });
+}
+
+test('user rejects a native chart without its required entity method', (t) => {
+ // Given the native chart no longer exposes the expected create method
+ const fixture = createChartDom();
+ t.after(() => fixture.dom.window.close());
+ delete fixture.chart.createShape;
+
+ // When the current TradingView target is validated
+ const failure = captureStrategyError(() => findStrategy27ChartTarget(fixture.dom.window.document, 'BTRUSDT'));
+
+ // Then the unavailable method is identified before marker work begins
+ assert.equal(failure.message, 'TradingView chart method is unavailable: createShape');
+ assert.equal(fixture.shapes.size, 0);
+});
+
+test('user rejects a chart with no native symbol instead of adopting the route symbol', (t) => {
+ // Given the frame is ready but its native symbol is absent
+ const fixture = createChartDom({ symbol: null });
+ t.after(() => fixture.dom.window.close());
+
+ // When route and native chart identity are checked together
+ const failure = captureStrategyError(() => findStrategy27ChartTarget(fixture.dom.window.document, 'BTRUSDT'));
+
+ // Then the symbol mismatch remains explicit
+ assert.equal(failure.message, 'Strategy 27 chart symbol mismatch: expected BTRUSDT, received ');
+});
+
+for (const [label, listedShapes, expected] of [
+ ['non-array list', null, 'Strategy 27 chart shape list is invalid'],
+ ['empty identity', [{ id: '' }], 'Strategy 27 chart shape id is invalid'],
+ ['numeric identity', [{ id: 42 }], 'Strategy 27 chart shape id is invalid'],
+ ['missing entity', [null], 'Strategy 27 chart shape id is invalid'],
+]) {
+ test(`user rejects native shape discovery with ${label}`, () => {
+ // Given the host returns the malformed list without repairing its entries
+ const boundary = createStrategyShapeBoundary({ listedShapes });
+
+ // When live native shape identities are read for reconciliation
+ const failure = captureStrategyError(() => readLiveShapeIds(boundary.chart));
+
+ // Then invalid native identities fail before any removal is attempted
+ assert.equal(failure.message, expected);
+ assert.deepEqual(boundary.removed, []);
+ });
+}
+
+for (const shapeId of [null, '', 42]) {
+ test(`user rejects native shape creation returning identity ${JSON.stringify(shapeId)}`, async () => {
+ // Given native creation returns an unusable entity identity
+ const boundary = createStrategyShapeBoundary({ shapeId });
+ const point = { time: 10, price: 1.25 };
+
+ // When the real aligned creation adapter receives that identity
+ const result = createAlignedShape(boundary.chart, point, { shape: 'arrow_up' });
+
+ // Then the unusable identity is reported without guessing which entity to remove
+ await assert.rejects(result, { message: 'TradingView returned an invalid shape id' });
+ assert.equal(boundary.created.length, 1);
+ assert.deepEqual(boundary.removed, []);
+ });
+}
+
+for (const [label, points, count] of [
+ ['missing points', null, null],
+ ['empty points', [], 0],
+ ['multiple points', [{ time: 10, price: 1.25 }, { time: 11, price: 1.26 }], 2],
+]) {
+ test(`user removes only the newly created marker after native ${label}`, async () => {
+ // Given native creation succeeds but its point collection violates the marker contract
+ const boundary = createStrategyShapeBoundary({ points });
+
+ // When the real aligned creation adapter verifies the native point collection
+ const result = createAlignedShape(boundary.chart, { time: 10, price: 1.25 }, { shape: 'arrow_up' });
+
+ // Then the invalid owned marker is removed and its alignment error remains visible
+ await assert.rejects(result, { message: `Strategy 27 chart time alignment failed: expected 10, received null (point count ${count})` });
+ assert.deepEqual(boundary.removed, ['native-shape']);
+ assert.equal(boundary.created.length, 1);
+ });
+}
+
+for (const [label, candle, expected] of [
+ ['non-array candle', { time: 10 }, 'Strategy 27 candle is invalid for 10'],
+ ['incomplete OHLC values', [10, 1.25], 'Strategy 27 candle is invalid for 10'],
+ ['mismatched candle time', [9, 1.25, 1.3, 1.2, 1.25], 'Strategy 27 candle is invalid for 10'],
+ ['non-finite high price', [10, 1.25, NaN, 1.2, 1.25], 'Strategy 27 candle prices are invalid for 10'],
+ ['missing low price', [10, 1.25, 1.3, undefined, 1.25], 'Strategy 27 candle prices are invalid for 10'],
+]) {
+ test(`user rejects native marker placement with ${label}`, (t) => {
+ // Given the native series exposes the malformed candle at the exact event second
+ const fixture = createChartDom({ candle });
+ t.after(() => fixture.dom.window.close());
+ const placement = createTradingViewMarkerPlacement(fixture.chart);
+ const controller = new AbortController();
+
+ // When causal placement inspects that native candle
+ const failure = captureStrategyError(() => placement.wait(annotation(), { signal: controller.signal }));
+
+ // Then the malformed native data is explicit and no listener or marker is installed
+ assert.equal(failure.message, expected);
+ assert.equal(fixture.dataUpdatedListenerCount, 0);
+ assert.equal(fixture.shapes.size, 0);
+ });
+}
+
+for (const [label, chartOptions, expected] of [
+ ['candle coordinate', { priceToCoordinate: () => NaN }, 'Strategy 27 candle coordinate is unavailable for 10'],
+ ['marker price', { coordinateToPrice: () => NaN }, 'Strategy 27 marker price is unavailable for 10'],
+]) {
+ test(`user rejects a non-finite native ${label}`, (t) => {
+ // Given the native price scale cannot provide the required finite mapping
+ const fixture = createChartDom(chartOptions);
+ t.after(() => fixture.dom.window.close());
+ const placement = createTradingViewMarkerPlacement(fixture.chart);
+ const signal = new AbortController().signal;
+
+ // When the real placement adapter asks the native scale for an arrow position
+ const failure = captureStrategyError(() => placement.wait(annotation(), { signal }));
+
+ // Then invalid geometry cannot become a guessed marker price
+ assert.equal(failure.message, expected);
+ assert.equal(fixture.dataUpdatedListenerCount, 0);
+ assert.equal(fixture.shapes.size, 0);
+ });
+}
+
+for (const [label, candidate, gapPx, expected] of [
+ ['unsupported marker shape', annotation({ markerShape: 'triangle' }), 8, 'Unsupported Strategy 27 marker shape: triangle'],
+ ['non-finite pixel gap', annotation(), Infinity, 'Strategy 27 marker pixel gap is invalid'],
+]) {
+ test(`user rejects ${label} before reading candle data`, (t) => {
+ // Given marker presentation includes an invalid public placement argument
+ const fixture = createChartDom();
+ t.after(() => fixture.dom.window.close());
+ const placement = createTradingViewMarkerPlacement(fixture.chart);
+ const signal = new AbortController().signal;
+
+ // When the native placement adapter receives that argument
+ const failure = captureStrategyError(() => placement.wait(candidate, { signal, gapPx }));
+
+ // Then the invalid presentation is reported without waiting or creating a marker
+ assert.equal(failure.message, expected);
+ assert.equal(fixture.dataUpdatedListenerCount, 0);
+ assert.equal(fixture.shapes.size, 0);
+ });
+}
+
+test('user rejects an unavailable native placement method at initialization', () => {
+ // Given the native chart has not exposed its time-scale API
+ const chart = {};
+
+ // When the real marker placement adapter initializes
+ const failure = captureStrategyError(() => createTradingViewMarkerPlacement(chart));
+
+ // Then the missing native method is identified without starting a candle wait
+ assert.equal(failure.message, 'TradingView marker placement method is unavailable: timePointToIndex');
+});
+
+for (const candleWaitMs of [0, 1.5]) {
+ test(`user rejects a candle wait deadline of ${candleWaitMs}`, (t) => {
+ // Given an invalid deadline was requested for a valid native chart
+ const fixture = createChartDom();
+ t.after(() => fixture.dom.window.close());
+
+ // When marker placement initializes with that deadline
+ const failure = captureStrategyError(() => createTradingViewMarkerPlacement(fixture.chart, { candleWaitMs }));
+
+ // Then the invalid deadline cannot create an unbounded or fractional wait
+ assert.equal(failure.message, 'Strategy 27 candleWaitMs is invalid');
+ assert.equal(fixture.dataUpdatedListenerCount, 0);
+ });
+}
+
+test('user cancels placement before any native candle read or subscription', async (t) => {
+ // Given cancellation already occurred and the native candle would otherwise be invalid
+ const fixture = createChartDom({ candle: {} });
+ t.after(() => fixture.dom.window.close());
+ const placement = createTradingViewMarkerPlacement(fixture.chart);
+ const controller = new AbortController();
+ controller.abort();
+
+ // When the cancelled caller requests marker placement
+ const point = await placement.wait(annotation(), { signal: controller.signal });
+
+ // Then cancellation returns no marker point and leaves no native subscription
+ assert.equal(point, null);
+ assert.equal(fixture.dataUpdatedListenerCount, 0);
+ assert.equal(fixture.shapes.size, 0);
+});
+
+test('user releases candle subscriptions when a later native update is malformed', async (t) => {
+ // Given placement is waiting on the native series for the event second
+ const fixture = createChartDom({ candle: null });
+ t.after(() => fixture.dom.window.close());
+ const placement = createTradingViewMarkerPlacement(fixture.chart);
+ const pending = placement.wait(annotation(), { signal: new AbortController().signal });
+ assert.equal(fixture.dataUpdatedListenerCount, 1);
+
+ // When the native data update supplies malformed candle content
+ fixture.setCandle({ incomplete: true });
+ fixture.fireDataUpdated();
+
+ // Then the actual data error rejects placement and its listener is removed
+ await assert.rejects(pending, { message: 'Strategy 27 candle is invalid for 10' });
+ assert.equal(fixture.dataUpdatedListenerCount, 0);
+ assert.equal(fixture.shapes.size, 0);
+});
+
+test('user cannot anchor an expired candle wait to a future native bar', async (t) => {
+ // Given the exact candle is absent and the native prior-candle lookup incorrectly points forward
+ t.mock.timers.enable({ apis: ['setTimeout'] });
+ const fixture = createChartDom({ candle: null, previousCandle: [11, 1.25, 1.3, 1.2, 1.25] });
+ t.after(() => fixture.dom.window.close());
+ const placement = createTradingViewMarkerPlacement(fixture.chart, { candleWaitMs: 25 });
+ const pending = placement.wait(annotation(), { signal: new AbortController().signal });
+
+ // When the bounded exact-candle deadline is reached
+ t.mock.timers.tick(24);
+ assert.equal(fixture.dataUpdatedListenerCount, 1);
+ t.mock.timers.tick(1);
+
+ // Then a future bar is rejected and the bounded wait releases its listener
+ await assert.rejects(pending, { message: 'Strategy 27 candle is invalid for 10' });
+ assert.equal(fixture.dataUpdatedListenerCount, 0);
+ assert.equal(fixture.shapes.size, 0);
+});
+
+test('user shifts a marker through the native price scale while preserving its candle time', (t) => {
+ // Given the exact native marker point is offset from its candle
+ const fixture = createChartDom();
+ t.after(() => fixture.dom.window.close());
+ const placement = createTradingViewMarkerPlacement(fixture.chart);
+
+ // When an additional eight-pixel vertical offset is requested
+ const shifted = placement.shift({ time: 10, price: 1.25 }, 8);
+
+ // Then the native inverse mapping determines price and candle time is unchanged
+ assert.deepEqual(shifted, { time: 10, price: 1.242 });
+});
+
+for (const [label, chartOptions, deltaPixels, expected] of [
+ ['invalid pixel delta', {}, Infinity, 'Strategy 27 marker pixel shift is invalid'],
+ ['unavailable native coordinate', { priceToCoordinate: () => NaN }, 8, 'Strategy 27 shifted marker coordinate is invalid'],
+ ['unavailable inverse price', { coordinateToPrice: () => NaN }, 8, 'Strategy 27 shifted marker coordinate is invalid'],
+]) {
+ test(`user rejects a marker shift with ${label}`, (t) => {
+ // Given the native scale or requested shift cannot provide valid coordinates
+ const fixture = createChartDom(chartOptions);
+ t.after(() => fixture.dom.window.close());
+ const placement = createTradingViewMarkerPlacement(fixture.chart);
+
+ // When the real marker placement adapter shifts its existing point
+ const failure = captureStrategyError(() => placement.shift({ time: 10, price: 1.25 }, deltaPixels));
+
+ // Then invalid geometry fails explicitly without creating an entity
+ assert.equal(failure.message, expected);
+ assert.equal(fixture.shapes.size, 0);
+ });
+}
+
+for (const [field, value] of [['maxEvents', 0], ['maxEvents', 1.5], ['maxAgeMs', 0], ['maxAgeMs', 1.5]]) {
+ test(`user rejects invalid ordinary marker retention ${field}=${value}`, (t) => {
+ // Given one retention bound violates the layer configuration contract
+ const fixture = createChartDom();
+ t.after(() => fixture.dom.window.close());
+ const options = { maxEvents: 2, maxAgeMs: 60000, [field]: value };
+
+ // When the real event layer initializes with that bound
+ const failure = captureStrategyError(() => createTradingViewEventLayer({ chart: fixture.chart }, options));
+
+ // Then the invalid bound is explicit and no chart entity is created
+ assert.equal(failure.message, `Strategy 27 ${field} is invalid`);
+ assert.equal(fixture.shapes.size, 0);
+ });
+}
+
+test('user does not restore an evicted marker after the native chart has changed symbols', async (t) => {
+ // Given the layer retains a verified BTR event whose native marker was evicted
+ const fixture = createChartDom();
+ t.after(() => fixture.dom.window.close());
+ const layer = createTradingViewEventLayer({ chart: fixture.chart }, { maxEvents: 2, maxAgeMs: 60000 });
+ await layer.renderOpened('event-a', annotation(), 10000);
+ fixture.shapes.delete('shape-1');
+ fixture.setSymbol('ETHUSDT');
+
+ // When an old event update arrives before the outer context sample
+ const rendered = await layer.renderUpdated('event-a', annotation(), 11000);
+
+ // Then the stale marker is not created on the replacement chart
+ assert.equal(rendered, false);
+ assert.equal(layer.size, 1);
+ assert.equal(fixture.shapes.size, 0);
+ assert.deepEqual(fixture.removed, []);
+ layer.clear();
+});
diff --git a/test/dom/binance-strategy29-bollinger/chart-runtime-boundaries.test.js b/test/dom/binance-strategy29-bollinger/chart-runtime-boundaries.test.js
new file mode 100644
index 0000000..57d4ac4
--- /dev/null
+++ b/test/dom/binance-strategy29-bollinger/chart-runtime-boundaries.test.js
@@ -0,0 +1,478 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createBollingerMonitor } from '../../../src/binance-strategy29-bollinger/monitor.js';
+import { detectBollingerSignals } from '../../../src/binance-strategy29-bollinger/core/bearish-bollinger-pattern.js';
+import {
+ bollingerIntervalVisibility, buildClosedBarsContentSnapshot, createBollingerIntervalSession,
+ createBollingerMarkerLayer, exportClosedTradingViewBars, findBearishBollingerChartTarget,
+ isBearishBollingerChartTargetCurrent, matchesClosedBarsContentSnapshot, parseClosedTradingViewBars,
+} from '../../../src/binance-strategy29-bollinger/dom/tradingview-bearish-alerts.js';
+import {
+ createOscillatingStrategyBars, createStrategy29ChartHost, exportStrategyBars,
+} from '../../helpers/strategy29-runtime-boundary-host.js';
+import { installStrategyClock, observeStrategyCondition } from '../../helpers/strategy-migration-boundaries.js';
+
+function monitorFixture(t, options) {
+ const host = createStrategy29ChartHost(options);
+ const clock = installStrategyClock(t, host.view, 20_000_000);
+ const state = { route: 'BTRUSDT', futures: true, busy: false };
+ const errors = [];
+ const warnings = [];
+ const monitor = createBollingerMonitor({
+ document: host.document,
+ getCurrentSymbol: () => state.route,
+ isFuturesTradingPage: () => state.futures,
+ isTradingViewDrawingMutationBusy: () => state.busy,
+ err: (...values) => errors.push(values),
+ warn: (...values) => warnings.push(values),
+ });
+ t.after(() => { state.busy = false; monitor.stop(); host.close(); });
+ return { host, clock, state, errors, warnings, monitor };
+}
+
+async function sample(fixture) {
+ await fixture.monitor.tick();
+ await observeStrategyCondition(() => {
+ fixture.clock.advance(0);
+ return !fixture.monitor.diagnostics.taskPending;
+ }, 'native export and marker rendering complete');
+}
+
+test('user sees both directions and reversal markers calculated from native OHLC candles', async (t) => {
+ // Given real oscillating OHLC candles and an unrelated user drawing.
+ const fixture = monitorFixture(t);
+ const { host, monitor } = fixture;
+ host.addForeignShape('user-line');
+
+ // When the real monitor exports candles and runs its detector and drawing layer.
+ await sample(fixture);
+
+ // Then each calculated event uses its directional shape and the pending shape starts hidden.
+ assert.deepEqual(host.created.map(({ point, options }) => [point.time, options.shape, options.overrides.color]), [
+ [7440, 'icon', '#F6465D'], [7500, 'arrow_down', '#F6465D'], [7740, 'arrow_up', '#0ECB81'],
+ [9360, 'icon', '#0ECB81'], [9900, 'arrow_down', '#F6465D'],
+ ]);
+ assert.equal(host.created.every(({ options }) => options.overrides.visible === false && options.disableSave === true), true);
+ assert.deepEqual(host.propertyWrites.map(({ properties }) => properties.visible), [true, true, true, true, true]);
+ assert.equal(monitor.diagnostics.cachedSignalCount, 5);
+ assert.equal(monitor.diagnostics.layerSize, 5);
+ assert.deepEqual(fixture.errors, []);
+
+ // When an explicit chart save and a repeated sample use the same candle content.
+ let saved;
+ host.tradingViewApi.saveChart(value => { saved = value; }, { explicit: true });
+ await sample(fixture);
+
+ // Then user drawings are saved and unchanged strategy markers are reused.
+ assert.deepEqual(saved, { drawings: [{ id: 'user-line' }] });
+ assert.equal(host.created.length, 5);
+ assert.deepEqual(host.removed, []);
+ assert.equal(host.exports.length, 2);
+});
+
+test('user removes obsolete strategy markers when revised native candles contain no signals', async (t) => {
+ // Given rendered strategy signals beside one user-owned line.
+ const fixture = monitorFixture(t);
+ fixture.host.addForeignShape('user-line');
+ await sample(fixture);
+
+ // When the same native window is corrected to valid flat-price candles.
+ fixture.host.setBars(createOscillatingStrategyBars().map(bar => ({ ...bar, open: 100, close: 100, high: 101, low: 99 })));
+ await sample(fixture);
+
+ // Then only the former strategy drawings are removed and the empty result is cached.
+ assert.deepEqual(fixture.host.removed, ['native-1', 'native-2', 'native-3', 'native-4', 'native-5']);
+ assert.deepEqual(fixture.host.chart.getAllShapes(), [{ id: 'user-line', name: 'trend_line' }]);
+ assert.equal(fixture.monitor.diagnostics.cachedSignalCount, 0);
+ assert.equal(fixture.monitor.diagnostics.layerSize, 0);
+ assert.deepEqual(fixture.errors, []);
+});
+
+for (const [label, properties] of [
+ ['icon', { icon: 0xf110 }],
+ ['interval visibility', { intervalsVisibilities: { minutes: false } }],
+]) {
+ test(`user repairs an externally changed marker ${label} without duplicating other signals`, async (t) => {
+ // Given five real signals whose first native drawing has been edited externally.
+ const fixture = monitorFixture(t);
+ await sample(fixture);
+ fixture.host.editProperties('native-1', properties);
+
+ // When the unchanged candle window is audited again.
+ await sample(fixture);
+
+ // Then the changed drawing is replaced and the complete real marker contract is restored.
+ assert.deepEqual(fixture.host.removed, ['native-1']);
+ assert.equal(fixture.host.created.length, 6);
+ assert.equal(fixture.monitor.diagnostics.layerSize, 5);
+ assert.deepEqual(fixture.host.shapes.get('native-6').getProperties(), {
+ visible: true, intervalsVisibilities: bollingerIntervalVisibility('1'), color: '#F6465D', size: 10, icon: 0xf111,
+ });
+ });
+}
+
+test('user stops publishing markers when native property writes are declined and clears the pending drawing', async (t) => {
+ // Given a native chart that accepts creation but declines property writes.
+ const fixture = monitorFixture(t);
+ fixture.host.addForeignShape('user-line');
+ fixture.host.ignorePropertyWrites(true);
+
+ // When the real monitor tries to reveal its first signal marker.
+ await sample(fixture);
+
+ // Then the unpublished marker is removed and diagnostics identify the fatal render failure.
+ assert.deepEqual(fixture.host.removed, ['native-1']);
+ assert.deepEqual(fixture.host.chart.getAllShapes(), [{ id: 'user-line', name: 'trend_line' }]);
+ assert.equal(fixture.monitor.diagnostics.failed, true);
+ assert.equal(fixture.monitor.diagnostics.cleanupPending, true);
+ assert.equal(fixture.monitor.diagnostics.lastLocalFailure.stage, 'render');
+ assert.equal(fixture.monitor.diagnostics.lastLocalFailure.message, 'TradingView Bollinger alert marker properties were not applied');
+ assert.equal(fixture.monitor.diagnostics.cachedSignalCount, null);
+ assert.equal(fixture.errors.length, 1);
+});
+
+test('user receives a fatal native-property diagnostic before old owned markers are cleaned on the next sample', async (t) => {
+ // Given an established signal layer whose native property readback becomes invalid.
+ const fixture = monitorFixture(t);
+ fixture.host.addForeignShape('user-line');
+ await sample(fixture);
+ fixture.host.setNativeProperties('native-1', null);
+
+ // When the next real audit reads the malformed external properties.
+ await sample(fixture);
+
+ // Then the existing layer is marked for cleanup without losing the original failure stage.
+ assert.equal(fixture.monitor.diagnostics.lastLocalFailure.message, 'TradingView Bollinger alert marker properties are invalid');
+ assert.equal(fixture.monitor.diagnostics.lastLocalFailure.layerSizeBeforeCleanup, 5);
+ assert.equal(fixture.monitor.diagnostics.cleanupPending, true);
+
+ // When another sample applies the queued cleanup.
+ await sample(fixture);
+
+ // Then all owned markers disappear, the foreign line survives, and no export is retried in the failed context.
+ assert.deepEqual(fixture.host.chart.getAllShapes(), [{ id: 'user-line', name: 'trend_line' }]);
+ assert.equal(fixture.monitor.diagnostics.layerSize, 0);
+ assert.equal(fixture.monitor.diagnostics.cleanupPending, false);
+ assert.equal(fixture.host.exports.length, 2);
+});
+
+for (const invalidId of ['', 42]) {
+ test(`user stops after a native marker creation returns ${invalidId === '' ? 'an empty ID' : 'a numeric ID'}`, async (t) => {
+ // Given a native creation response that violates the external chart contract.
+ const fixture = monitorFixture(t);
+ fixture.host.returnNextCreationId(invalidId);
+
+ // When the first detected marker awaits that native response.
+ await sample(fixture);
+
+ // Then no ID is claimed or removed and the render failure is retained.
+ assert.equal(fixture.monitor.diagnostics.lastLocalFailure.message, 'TradingView returned an invalid Bollinger alert shape id');
+ assert.equal(fixture.monitor.diagnostics.failed, true);
+ assert.equal(fixture.monitor.diagnostics.layerSize, 0);
+ assert.equal(fixture.host.created.length, 1);
+ assert.deepEqual(fixture.host.removed, []);
+ assert.equal(fixture.host.shapes.size, 0);
+ });
+}
+
+test('user discards a marker whose native readback races leaving the futures page', async (t) => {
+ // Given a real signal whose native point read occurs as the route is retired.
+ const fixture = monitorFixture(t);
+ fixture.host.onNextPointRead(() => { fixture.state.futures = false; });
+
+ // When marker creation finishes and the layer reads its point.
+ await sample(fixture);
+
+ // Then the pending drawing never becomes visible and is removed without recording a terminal error.
+ assert.equal(fixture.host.created.length, 1);
+ assert.deepEqual(fixture.host.propertyWrites, []);
+ assert.deepEqual(fixture.host.removed, ['native-1']);
+ assert.equal(fixture.monitor.diagnostics.cachedSignalCount, null);
+ assert.equal(fixture.monitor.diagnostics.failed, false);
+ assert.deepEqual(fixture.errors, []);
+});
+
+test('user defers retired drawing cleanup while another drawing owner is busy and resumes afterward', async (t) => {
+ // Given real signal candles whose first native marker creation is still pending.
+ const fixture = monitorFixture(t);
+ const gate = fixture.host.holdNextCreation();
+ await fixture.monitor.tick();
+ await gate.entered;
+
+ // When stop invalidates that context while the host reports a drawing owner as busy.
+ fixture.state.busy = true;
+ fixture.monitor.stop();
+ gate.release();
+ await observeStrategyCondition(() => !fixture.monitor.diagnostics.taskPending, 'retired native creation settles');
+
+ // Then the late result remains owned and hidden while mutation is deferred.
+ assert.equal(fixture.monitor.diagnostics.contextPresent, false);
+ assert.equal(fixture.monitor.diagnostics.retiredCount, 1);
+ assert.equal(fixture.host.shapes.get('native-1').properties.visible, false);
+ assert.deepEqual(fixture.host.removed, []);
+ assert.deepEqual(fixture.host.propertyWrites, []);
+
+ // When the drawing owner releases the page and the monitor samples again.
+ fixture.state.busy = false;
+ await sample(fixture);
+
+ // Then the retired result is removed before one fresh complete layer is published.
+ assert.deepEqual(fixture.host.removed, ['native-1']);
+ assert.equal(fixture.monitor.diagnostics.retiredCount, 0);
+ assert.equal(fixture.monitor.diagnostics.cachedSignalCount, 5);
+ assert.equal(fixture.monitor.diagnostics.layerSize, 5);
+ assert.equal(fixture.host.shapes.size, 5);
+});
+
+test('user ignores a late export error from a retired interval and renders the fresh interval', async (t) => {
+ // Given a pending native export in the one-minute interval.
+ const fixture = monitorFixture(t);
+ const gate = fixture.host.holdNextExport();
+ await fixture.monitor.tick();
+ await gate.entered;
+
+ // When the chart completes a five-minute transition before the old export rejects.
+ fixture.host.changeInterval('5');
+ fixture.host.setBars(createOscillatingStrategyBars().map(bar => ({ ...bar, time: bar.time * 5 })));
+ fixture.host.finishData();
+ fixture.clock.setTime(100_000_000);
+ await fixture.monitor.tick();
+ gate.reject(new Error('retired one-minute export'));
+ await observeStrategyCondition(() => !fixture.monitor.diagnostics.taskPending, 'old export rejection settles');
+ await sample(fixture);
+
+ // Then the stale failure is ignored and every published marker belongs to the new interval.
+ assert.deepEqual(fixture.errors, []);
+ assert.equal(fixture.monitor.diagnostics.lastLocalFailure, null);
+ assert.equal(fixture.monitor.diagnostics.failed, false);
+ assert.equal(fixture.monitor.diagnostics.layerSize, 5);
+ assert.deepEqual(fixture.host.created.map(({ point }) => point.time), [37200, 37500, 38700, 46800, 49500]);
+ assert.equal(fixture.host.created.every(({ options }) => options.overrides.intervalsVisibilities.minutesFrom === 5), true);
+});
+
+for (const [label, reason, thrownType, name, message] of [
+ ['a string', 'native export rejected', 'string', null, 'native export rejected'],
+ ['null', null, 'null', null, null],
+ ['a numeric field object', { name: 7, message: 8 }, 'object', null, null],
+]) {
+ test(`user receives bounded diagnostics when the native export rejects with ${label}`, async (t) => {
+ // Given a native export rejection with a supported JavaScript rejection type.
+ const fixture = monitorFixture(t);
+ fixture.host.failNextExport(reason);
+
+ // When the real monitor receives the external rejection.
+ await sample(fixture);
+
+ // Then the exact rejection type is retained without inventing a string or signal cache.
+ assert.deepEqual(fixture.monitor.diagnostics.lastLocalFailure, {
+ thrownType, classificationFailed: false, name, message, unreadableFields: [], stage: 'export',
+ routeSymbol: 'BTRUSDT', resolution: '1', cachedSignalCount: null, layerSizeBeforeCleanup: 0,
+ sessionRevision: 0, contextIntervalRevision: 0,
+ });
+ assert.equal(fixture.monitor.diagnostics.failed, true);
+ assert.equal(fixture.errors.length, 1);
+ assert.equal(fixture.errors[0][1], reason);
+ assert.deepEqual(fixture.host.created, []);
+ });
+}
+
+test('user waits through hidden pages, missing routes, busy drawings and an incomplete native interval', async (t) => {
+ // Given a visible chart and real monitor that has not yet exported any candles.
+ const fixture = monitorFixture(t);
+
+ // When each native readiness boundary temporarily prevents a sample.
+ fixture.host.setHidden(true);
+ await sample(fixture);
+ fixture.host.setHidden(false);
+ fixture.state.route = null;
+ await sample(fixture);
+ fixture.state.route = 'BTRUSDT';
+ fixture.state.busy = true;
+ await sample(fixture);
+ fixture.state.busy = false;
+ fixture.host.changeInterval('1');
+ await sample(fixture);
+
+ // Then no premature export or marker is created.
+ assert.equal(fixture.host.exports.length, 0);
+ assert.equal(fixture.host.created.length, 0);
+ assert.equal(fixture.monitor.diagnostics.contextPresent, false);
+
+ // When native data completion and normal drawing ownership become observable.
+ fixture.host.finishData();
+ await sample(fixture);
+ fixture.state.busy = true;
+ await sample(fixture);
+
+ // Then the completed interval renders once and an established busy layer remains untouched.
+ assert.equal(fixture.host.exports.length, 1);
+ assert.equal(fixture.host.created.length, 5);
+ assert.equal(fixture.monitor.diagnostics.layerSize, 5);
+});
+
+test('user waits for a closed candle and discards an export when the page becomes hidden', async (t) => {
+ // Given a native export window whose first candle is still open.
+ const fixture = monitorFixture(t, { bars: createOscillatingStrategyBars(1) });
+ fixture.clock.setTime(119_999);
+ await sample(fixture);
+ const gate = fixture.host.holdNextExport();
+
+ // When the next sample is hidden while awaiting the native export.
+ await fixture.monitor.tick();
+ await gate.entered;
+ fixture.host.setHidden(true);
+ gate.resolve(exportStrategyBars(createOscillatingStrategyBars()));
+ await observeStrategyCondition(() => !fixture.monitor.diagnostics.taskPending, 'hidden export settles');
+
+ // Then neither an open candle nor a hidden response commits detector output.
+ assert.equal(fixture.host.exports.length, 2);
+ assert.equal(fixture.monitor.diagnostics.cachedSignalCount, null);
+ assert.deepEqual(fixture.host.created, []);
+ assert.deepEqual(fixture.errors, []);
+});
+
+for (const transition of ['interval', 'symbol', 'disposed']) {
+ test(`user rejects a held native candle export after its ${transition} context changes`, async (t) => {
+ // Given a real interval session and a held external export.
+ const host = createStrategy29ChartHost();
+ const target = findBearishBollingerChartTarget(host.document, 'BTRUSDT');
+ const session = createBollingerIntervalSession(host.chart);
+ t.after(() => { session.dispose(); host.close(); });
+ const gate = host.holdNextExport();
+ const pending = exportClosedTradingViewBars(target, session, 20_000_000);
+ await gate.entered;
+
+ // When the native context retires before its OHLC response arrives.
+ if (transition === 'interval') { host.changeInterval('5'); host.finishData(); }
+ if (transition === 'symbol') host.setSymbol('BTCUSDT@PRICETYPE=LAST');
+ if (transition === 'disposed') session.dispose();
+ gate.resolve(exportStrategyBars(createOscillatingStrategyBars()));
+ const result = await pending;
+
+ // Then the late bars are discarded and disposal removes both owned native subscriptions exactly once.
+ assert.equal(result, null);
+ session.dispose();
+ session.dispose();
+ assert.equal(host.intervalChanged.size, 0);
+ assert.equal(host.dataLoaded.size, 0);
+ assert.equal(host.exports.length, 1);
+ });
+}
+
+test('user stops recognizing a chart target when the native chart or its model disappears', (t) => {
+ // Given a fully initialized native target.
+ const host = createStrategy29ChartHost();
+ t.after(() => host.close());
+ const target = findBearishBollingerChartTarget(host.document, 'BTRUSDT');
+
+ // When the active chart and model become unavailable at separate host lifecycle boundaries.
+ host.setActiveChart(null);
+ const missingChart = isBearishBollingerChartTargetCurrent(host.document, target);
+ host.setActiveChart(host.chart);
+ host.setModelReady(false);
+ const missingModel = isBearishBollingerChartTargetCurrent(host.document, target);
+ host.setModelReady(true);
+ const restored = isBearishBollingerChartTargetCurrent(host.document, target);
+
+ // Then only the restored native chart is current.
+ assert.deepEqual({ missingChart, missingModel, restored }, { missingChart: false, missingModel: false, restored: true });
+});
+
+for (const [resolution, unit, count] of [['10S', 'seconds', 10], ['1D', 'days', 1], ['2H', 'hours', 2], ['90', 'hours', 1]]) {
+ test(`user keeps ${resolution} markers visible only in their native interval bucket`, () => {
+ // Given an observed native interval that the chart groups into one visibility bucket.
+ const interval = resolution;
+
+ // When the production adapter computes the drawing visibility contract.
+ const visibility = bollingerIntervalVisibility(interval);
+
+ // Then exactly that native unit and count are enabled.
+ assert.deepEqual(visibility, {
+ ticks: false, seconds: false, minutes: false, hours: false, days: false, weeks: false,
+ months: false, ranges: false, [unit]: true, [`${unit}From`]: count, [`${unit}To`]: count,
+ });
+ });
+}
+
+for (const [label, change, expected] of [
+ ['schema', value => { value.schema = null; }, /export schema is invalid/],
+ ['data list', value => { value.data = {}; }, /export data is invalid/],
+ ['row', value => { value.data[0] = null; }, /export row 0 is invalid/],
+ ['time', value => { value.data[0][0] = 60.5; }, /export time 0 is invalid/],
+ ['close', value => { value.data[0][4] = null; }, /export close 0 is invalid/],
+]) {
+ test(`user receives a specific error for a malformed native export ${label}`, async (t) => {
+ // Given a declared malformed native response without repairing its fields in the host.
+ const fixture = monitorFixture(t);
+ const exported = exportStrategyBars(createOscillatingStrategyBars(2));
+ change(exported);
+ fixture.host.exportNext(exported);
+
+ // When the real monitor parses the exported response.
+ await sample(fixture);
+
+ // Then the external contract failure stops this context before detector or drawing work.
+ assert.match(fixture.monitor.diagnostics.lastLocalFailure.message, expected);
+ assert.equal(fixture.monitor.diagnostics.lastLocalFailure.stage, 'export');
+ assert.equal(fixture.monitor.diagnostics.failed, true);
+ assert.deepEqual(fixture.host.created, []);
+ });
+}
+
+test('user rejects off-grid weekly and mis-spaced multi-day exports while accepting valid calendar phases', () => {
+ // Given valid OHLC rows anchored on Monday and a multi-day grid unrelated to the Unix epoch phase.
+ const monday = Date.UTC(2026, 8, 14) / 1000;
+ const bar = { open: 100, high: 102, low: 99, close: 101 };
+ const weekly = exportStrategyBars([{ ...bar, time: monday }, { ...bar, time: monday + 604800 }]);
+ const multiDay = exportStrategyBars([{ ...bar, time: monday }, { ...bar, time: monday + 172800 }]);
+
+ // When valid calendar feeds and their corresponding host mistakes are parsed.
+ const weekBars = parseClosedTradingViewBars(weekly, { resolution: '1W', resolutionSeconds: 604800, observedAtSeconds: monday + 1209600 });
+ const dayBars = parseClosedTradingViewBars(multiDay, { resolution: '2D', resolutionSeconds: 172800, observedAtSeconds: monday + 345600 });
+ const tuesday = exportStrategyBars([{ ...bar, time: monday + 86400 }]);
+ const wrongSpacing = exportStrategyBars([{ ...bar, time: monday }, { ...bar, time: monday + 86400 }]);
+
+ // Then valid phase-aligned bars are retained and concrete grid mistakes are classified as retryable snapshots.
+ assert.deepEqual(weekBars.map(item => item.time), [monday, monday + 604800]);
+ assert.deepEqual(dayBars.map(item => item.time), [monday, monday + 172800]);
+ assert.throws(() => parseClosedTradingViewBars(tuesday, { resolution: '1W', resolutionSeconds: 604800, observedAtSeconds: monday + 1209600 }), { name: 'TradingViewBarSnapshotInconsistentError', message: /interval grid is invalid at 0/ });
+ assert.throws(() => parseClosedTradingViewBars(wrongSpacing, { resolution: '2D', resolutionSeconds: 172800, observedAtSeconds: monday + 345600 }), { name: 'TradingViewBarSnapshotInconsistentError', message: /interval spacing is invalid at 1/ });
+});
+
+test('user invalidates a closed-candle content snapshot when its native window expands', () => {
+ // Given a concrete two-candle export and its immutable content snapshot.
+ const bars = createOscillatingStrategyBars(2);
+ const snapshot = buildClosedBarsContentSnapshot(bars);
+
+ // When the next native export contains one additional closed candle.
+ const expanded = matchesClosedBarsContentSnapshot(createOscillatingStrategyBars(3), snapshot);
+ const unchanged = matchesClosedBarsContentSnapshot(bars, snapshot);
+
+ // Then the longer window cannot reuse the former detector result.
+ assert.equal(expanded, false);
+ assert.equal(unchanged, true);
+ assert.equal(snapshot.windowKey, '2:60:120');
+ assert.equal(snapshot.values.length, 10);
+});
+
+test('user leaves markers untouched when direct rendering loses drawing ownership', async (t) => {
+ // Given real detector output and a layer whose native drawing owner is busy.
+ const host = createStrategy29ChartHost();
+ installStrategyClock(t, host.view, 20_000_000);
+ t.after(() => host.close());
+ const target = findBearishBollingerChartTarget(host.document, 'BTRUSDT');
+ const signals = detectBollingerSignals(createOscillatingStrategyBars());
+ let busy = true;
+ const layer = createBollingerMarkerLayer(target, { canMutate: () => !busy });
+
+ // When rendering is requested during host ownership and then against a stale page context.
+ const blocked = await layer.render(signals, { isCurrent: () => true });
+ busy = false;
+ const stale = await layer.render(signals, { isCurrent: () => false });
+
+ // Then neither request creates or removes a native drawing.
+ assert.deepEqual({ blocked, stale }, { blocked: false, stale: false });
+ assert.equal(layer.size, 0);
+ assert.deepEqual(host.created, []);
+ assert.deepEqual(host.removed, []);
+});
diff --git a/test/dom/binance-strategy29-bollinger/native-provider-boundaries.test.js b/test/dom/binance-strategy29-bollinger/native-provider-boundaries.test.js
new file mode 100644
index 0000000..1d765e1
--- /dev/null
+++ b/test/dom/binance-strategy29-bollinger/native-provider-boundaries.test.js
@@ -0,0 +1,217 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import test from 'node:test';
+import { createBollingerMonitor } from '../../../src/binance-strategy29-bollinger/monitor.js';
+import { createStrategy29RemoteSummary, STRATEGY29_PANEL_POSITION_KEY } from '../../../src/binance-strategy29-bollinger/remote-summary.js';
+import { createStrategy29SummaryPanel } from '../../../src/binance-strategy29-bollinger/dom/strategy29-summary-panel.js';
+import { createBollingerIntervalSession } from '../../../src/binance-strategy29-bollinger/dom/tradingview-bearish-alerts.js';
+import { validateStrategy29EventsResponse, validateStrategy29StatusResponse } from '../../../src/binance-strategy29-bollinger/core/remote-summary-contract.js';
+import { SUMMARY_COPY } from '../../../src/binance-strategy29-bollinger/ui-copy.js';
+import { createStrategy29ChartHost, createStrategy29RequestHost } from '../../helpers/strategy29-runtime-boundary-host.js';
+import { captureStrategyError, installStrategyClock, observeStrategyCondition } from '../../helpers/strategy-migration-boundaries.js';
+
+const status = JSON.parse(await readFile(new URL('../../fixtures/strategy29-gateway-status.json', import.meta.url)));
+const events = JSON.parse(await readFile(new URL('../../fixtures/strategy29-gateway-events.json', import.meta.url)));
+
+function remoteConfiguration(host, transport, reads, writes) {
+ return {
+ view: host.view, request: request => transport.request(request),
+ getValue(key) { assert.equal(key, STRATEGY29_PANEL_POSITION_KEY); reads.push(key); return null; },
+ setValue(key, value) { writes.push({ key, value }); },
+ getGatewayState: () => ({ available: true, configured: true, settingsRevision: 1 }),
+ pollIntervalMs: 1000,
+ };
+}
+
+for (const [label, changed, message] of [
+ ['missing page window', { view: null }, 'Strategy 29 remote summary requires a page window'],
+ ['missing position writer', { setValue: null }, 'Strategy 29 remote summary setValue is invalid'],
+ ['too-short poll interval', { pollIntervalMs: 999 }, 'Strategy 29 remote poll interval is invalid'],
+]) {
+ test(`user rejects a remote summary with ${label} before installing a panel`, async (t) => {
+ // Given an invalid public remote-summary configuration and a fresh page.
+ const host = createStrategy29ChartHost();
+ host.dom.reconfigure({ url: 'https://www.binance.com/en/futures/BTCUSDT' });
+ const transport = createStrategy29RequestHost();
+ const reads = [];
+ const writes = [];
+ const configuration = remoteConfiguration(host, transport, reads, writes);
+ t.after(() => host.close());
+
+ // When the public constructor validates the configured adapters and poll boundary.
+ const error = captureStrategyError(() => createStrategy29RemoteSummary({ ...configuration, ...changed }));
+
+ // Then initialization fails before storage, transport or visible page state is touched.
+ assert.equal(error.name, 'TypeError');
+ assert.equal(error.message, message);
+ assert.deepEqual(reads, []);
+ assert.deepEqual(writes, []);
+ assert.deepEqual(transport.requests, []);
+ assert.equal(host.document.getElementById('jh-strategy29-summary-panel'), null);
+
+ // When corrected adapters use the supported one-second minimum and receive a real snapshot.
+ const remote = createStrategy29RemoteSummary(configuration);
+ t.after(() => remote.dispose());
+ transport.respond(status);
+ transport.respond(events);
+ await remote.sample(status.observed_at_ms);
+
+ // Then the default client and panel connect normally using only the declared position key.
+ assert.equal(remote.diagnostics.state, 'connected');
+ assert.equal(remote.diagnostics.cursor, 42);
+ assert.deepEqual(reads, [STRATEGY29_PANEL_POSITION_KEY]);
+ assert.equal(host.document.querySelectorAll('[data-role=remote-event]').length, 2);
+ assert.deepEqual(writes, []);
+ remote.dispose();
+ });
+}
+
+for (const [label, mode, message] of [
+ ['a body element', 'body', 'Strategy 29 summary panel requires document.body'],
+ ['a nonempty symbol', 'symbol', 'Strategy 29 panel symbol is invalid'],
+ ['position adapters', 'adapters', 'Strategy 29 panel position adapters are required'],
+]) {
+ test(`user requires ${label} before a summary panel is inserted`, (t) => {
+ // Given a real document whose public panel initialization prerequisite is absent.
+ const host = createStrategy29ChartHost();
+ t.after(() => host.close());
+ if (mode === 'body') host.document.body.remove();
+ const reads = [];
+ const writes = [];
+ const options = {
+ locale: 'en', loadPosition: () => { reads.push('position'); return null; },
+ savePosition: position => writes.push(position),
+ };
+ if (mode === 'adapters') options.loadPosition = null;
+
+ // When the public panel factory is called before that prerequisite is satisfied.
+ const error = captureStrategyError(() => createStrategy29SummaryPanel(host.document, mode === 'symbol' ? '' : 'BTC/USDT:USDT', options));
+
+ // Then the missing prerequisite is reported and no partial panel or storage write is left behind.
+ assert.equal(error.message, message);
+ assert.equal(host.document.getElementById('jh-strategy29-summary-panel'), null);
+ assert.deepEqual(reads, []);
+ assert.deepEqual(writes, []);
+ });
+}
+
+test('user cannot mutate a destroyed summary panel through any retained public update callback', (t) => {
+ // Given a real panel with validated status and events that has been retired.
+ const host = createStrategy29ChartHost();
+ t.after(() => host.close());
+ const writes = [];
+ const panel = createStrategy29SummaryPanel(host.document, 'BTC/USDT:USDT', {
+ locale: 'en', loadPosition: () => null, savePosition: value => writes.push(value),
+ });
+ const validatedStatus = validateStrategy29StatusResponse(status, 200);
+ const validatedEvents = validateStrategy29EventsResponse(events, 200);
+ panel.renderStatus(validatedStatus);
+ panel.addEvents(validatedEvents.events, validatedEvents.observed_at_ms);
+ const element = host.document.getElementById('jh-strategy29-summary-panel');
+ panel.destroy();
+ const markupAfterRetirement = element.innerHTML;
+
+ // When late public update callbacks attempt to render into the destroyed panel.
+ const errors = [
+ () => panel.setLocale('zh-CN'),
+ () => panel.setConnection('connected', SUMMARY_COPY.connected),
+ () => panel.renderStatus(validatedStatus),
+ () => panel.addEvents(validatedEvents.events, validatedEvents.observed_at_ms),
+ () => panel.clearEvents(),
+ ].map(operation => captureStrategyError(operation));
+
+ // Then every late update is explicitly rejected and no DOM or persistence state changes.
+ assert.deepEqual(errors.map(error => error.message), Array(5).fill('Strategy 29 summary panel is destroyed'));
+ assert.equal(element.innerHTML, markupAfterRetirement);
+ assert.equal(element.isConnected, false);
+ assert.equal(panel.size, 0);
+ assert.deepEqual(writes, []);
+});
+
+function monitorFixture(t, options) {
+ const host = createStrategy29ChartHost(options);
+ const clock = installStrategyClock(t, host.view, 20_000_000);
+ const errors = [];
+ const warnings = [];
+ const monitor = createBollingerMonitor({
+ document: host.document, getCurrentSymbol: () => 'BTRUSDT', isFuturesTradingPage: () => true,
+ isTradingViewDrawingMutationBusy: () => false,
+ err: (...values) => errors.push(values), warn: (...values) => warnings.push(values),
+ });
+ t.after(() => { monitor.stop(); host.close(); });
+ return { host, clock, errors, warnings, monitor };
+}
+
+async function sample(fixture) {
+ await fixture.monitor.tick();
+ await observeStrategyCondition(() => {
+ fixture.clock.advance(0);
+ return !fixture.monitor.diagnostics.taskPending;
+ }, 'provider boundary sample completes');
+}
+
+for (const [label, options, change, expected] of [
+ ['omitted candle-export capability', { omittedMethods: ['exportData'] }, null, 'TradingView Bollinger alert method is unavailable: exportData'],
+ ['missing native symbol', {}, host => host.setSymbol(null), 'TradingView Bollinger alert symbol mismatch: expected BTRUSDT, received '],
+ ['missing native resolution', { resolution: null }, null, 'TradingView Bollinger alert resolution is unsupported: null'],
+]) {
+ test(`user does not start an observer against a chart with ${label}`, async (t) => {
+ // Given an exposed native chart whose reported capabilities are incomplete.
+ const fixture = monitorFixture(t, options);
+ if (change) change(fixture.host);
+ fixture.host.addForeignShape('user-line');
+
+ // When the real monitor resolves its chart target.
+ await sample(fixture);
+
+ // Then the exact external capability failure is reported before an export or drawing mutation.
+ assert.equal(fixture.errors.length, 1);
+ assert.equal(fixture.errors[0][0], 'Bollinger chart lookup failed for this sample:');
+ assert.equal(fixture.errors[0][1].message, expected);
+ assert.equal(fixture.monitor.diagnostics.contextPresent, false);
+ assert.equal(fixture.monitor.diagnostics.sessionPresent, false);
+ assert.deepEqual(fixture.host.exports, []);
+ assert.deepEqual(fixture.host.created, []);
+ assert.deepEqual(fixture.host.chart.getAllShapes(), [{ id: 'user-line', name: 'trend_line' }]);
+ });
+}
+
+for (const [label, list, expected] of [
+ ['non-array shape list', null, 'TradingView Bollinger alert shape list is invalid'],
+ ['nonnative shape identifier', [{ id: 7, name: 'icon' }], 'TradingView Bollinger alert shape 0 id is invalid'],
+]) {
+ test(`user stops marker publication after a native ${label} and keeps unrelated drawings`, async (t) => {
+ // Given real signal candles and a malformed list supplied by the native chart API.
+ const fixture = monitorFixture(t);
+ fixture.host.addForeignShape('user-line');
+ fixture.host.listShapesNext(list);
+
+ // When the real detector completes and the marker layer audits native ownership.
+ await sample(fixture);
+
+ // Then the render contract failure is retained without creating or deleting any drawing.
+ assert.equal(fixture.monitor.diagnostics.failed, true);
+ assert.equal(fixture.monitor.diagnostics.lastLocalFailure.stage, 'render');
+ assert.equal(fixture.monitor.diagnostics.lastLocalFailure.message, expected);
+ assert.equal(fixture.monitor.diagnostics.cachedSignalCount, null);
+ assert.deepEqual(fixture.host.created, []);
+ assert.deepEqual(fixture.host.removed, []);
+ assert.deepEqual(fixture.host.chart.getAllShapes(), [{ id: 'user-line', name: 'trend_line' }]);
+ });
+}
+
+test('user rejects an unavailable interval subscription without attaching half a readiness session', (t) => {
+ // Given a native chart that has not exposed its interval subscription interface.
+ const host = createStrategy29ChartHost();
+ t.after(() => host.close());
+ host.setIntervalSubscription(null);
+
+ // When the public interval-session factory checks the native readiness capabilities.
+ const error = captureStrategyError(() => createBollingerIntervalSession(host.chart));
+
+ // Then initialization fails before either native subscription is attached.
+ assert.equal(error.message, 'TradingView Bollinger interval subscription is unavailable');
+ assert.equal(host.intervalChanged.size, 0);
+ assert.equal(host.dataLoaded.size, 0);
+ assert.deepEqual(host.exports, []);
+});
diff --git a/test/dom/binance-strategy29-bollinger/runtime.test.js b/test/dom/binance-strategy29-bollinger/runtime.test.js
index ec7e630..e3b1458 100644
--- a/test/dom/binance-strategy29-bollinger/runtime.test.js
+++ b/test/dom/binance-strategy29-bollinger/runtime.test.js
@@ -3,28 +3,33 @@ import { readFile } from 'node:fs/promises';
import test from 'node:test';
import { JSDOM } from 'jsdom';
import { installStrategy29 } from '../../../src/binance-strategy29-bollinger/runtime.js';
+import { installStrategyClock, observeStrategyCondition } from '../../helpers/strategy-migration-boundaries.js';
const gatewayStatus = JSON.parse(await readFile(new URL('../../fixtures/strategy29-gateway-status.json', import.meta.url)));
const gatewayEvents = JSON.parse(await readFile(new URL('../../fixtures/strategy29-gateway-events.json', import.meta.url)));
-function fixture() {
+function fixture(t) {
const dom = new JSDOM('', { url: 'https://www.binance.com/en/futures/BTRUSDT' });
const view = dom.window;
- let hidden = false, next = 0;
- const timers = new Map();
+ let hidden = false;
+ const clock = installStrategyClock(t, view);
Object.defineProperty(view.document, 'hidden', { get: () => hidden });
view.console.warn = () => {};
- view.setInterval = callback => { timers.set(++next, callback); return next; };
- view.clearInterval = id => timers.delete(id);
- return { dom, view, timers,
- tick() { for (const callback of timers.values()) callback(); },
+ return { dom, view, timers: clock.intervals,
+ tick() { clock.advance(1000); },
+ advance: clock.advance,
+ setHidden(value) { hidden = value; },
hide(value) { hidden = value; view.document.dispatchEvent(new view.Event('visibilitychange')); } };
}
-test('standalone injection is single-instance and pauses/resumes/disposes its only timer', () => {
- const f = fixture();
+test('user observes that standalone injection is single-instance and pauses/resumes/disposes its only timer', (t) => {
+ // Given the standalone Strategy 29 page and runtime dependencies
+ const f = fixture(t);
+ // When installStrategy29 processes the configured inputs
const runtime = installStrategy29(f.view);
- assert.equal(installStrategy29(f.view), runtime);
+ const observedResult = installStrategy29(f.view);
+ // Then user observes that standalone injection is single-instance and pauses/resumes/disposes its only timer
+ assert.equal(observedResult, runtime);
assert.equal(f.timers.size, 1);
f.hide(true);
assert.equal(f.timers.size, 0);
@@ -39,12 +44,14 @@ test('standalone injection is single-instance and pauses/resumes/disposes its on
f.dom.window.close();
});
-test('remote transport failure never stops the local observer timer', async () => {
- const f = fixture();
+test('user observes that remote transport failure never stops the local observer timer', async (t) => {
+ // Given the standalone Strategy 29 page and runtime dependencies
+ const f = fixture(t);
const values = new Map([
['strategy29GatewayAuthSecret', 'synthetic-secret'],
['strategy29GatewayOrigin', 'http://127.0.0.1:8729'],
]);
+ // When installStrategy29 processes the configured inputs
const runtime = installStrategy29(f.view, {
request: async () => { throw new Error('synthetic remote failure'); },
getValue: (key, fallback) => values.has(key) ? values.get(key) : fallback,
@@ -52,7 +59,8 @@ test('remote transport failure never stops the local observer timer', async () =
registerMenuCommand() {},
getGatewayState() { return { available: true, configured: true, settingsRevision: 0 }; },
});
- await new Promise(resolve => f.view.setTimeout(resolve, 0));
+ await observeStrategyCondition(() => runtime.diagnostics.remoteSummary.state === 'stopped', 'remote transport failure');
+ // Then user observes that remote transport failure never stops the local observer timer
assert.equal(runtime.diagnostics.runtimeFailure, null);
assert.equal(runtime.diagnostics.remoteSummary.state, 'stopped');
assert.equal(f.timers.size, 1);
@@ -67,12 +75,14 @@ for (const [name, remoteResponse, expectedState] of [
['invalid JSON', { status: 200, responseText: '' }, 'stopped'],
['spec mismatch', { status: 200, responseText: JSON.stringify({ ...gatewayStatus, spec_version: 'other_spec' }) }, 'incompatible'],
]) {
- test(`${name} remains a remote-only state while the local timer continues`, async () => {
- const f = fixture();
+ test(`user observes that ${name} remains a remote-only state while the local timer continues`, async (t) => {
+ // Given the standalone Strategy 29 page and runtime dependencies
+ const f = fixture(t);
const values = new Map([
['strategy29GatewayAuthSecret', 'synthetic-secret'],
['strategy29GatewayOrigin', 'http://127.0.0.1:8729'],
]);
+ // When installStrategy29 processes the configured inputs
const runtime = installStrategy29(f.view, {
request: async () => remoteResponse,
getValue: (key, fallback) => values.has(key) ? values.get(key) : fallback,
@@ -80,7 +90,8 @@ for (const [name, remoteResponse, expectedState] of [
registerMenuCommand() {},
getGatewayState() { return { available: true, configured: true, settingsRevision: 0 }; },
});
- await new Promise(resolve => f.view.setTimeout(resolve, 0));
+ await observeStrategyCondition(() => runtime.diagnostics.remoteSummary.state === expectedState, `remote ${name} response`);
+ // Then user observes that the selected case remains a remote-only state while the local timer continues
assert.equal(runtime.diagnostics.runtimeFailure, null);
assert.equal(runtime.diagnostics.remoteSummary.state, expectedState);
assert.equal(f.timers.size, 1);
@@ -89,13 +100,15 @@ for (const [name, remoteResponse, expectedState] of [
});
}
-test('hiding the page aborts the remote request and resumes with one shared runtime timer', async () => {
- const f = fixture();
+test('user observes that hiding the page aborts the remote request and resumes with one shared runtime timer', async (t) => {
+ // Given the standalone Strategy 29 page and runtime dependencies
+ const f = fixture(t);
const values = new Map([
['strategy29GatewayAuthSecret', 'synthetic-secret'],
['strategy29GatewayOrigin', 'http://127.0.0.1:8729'],
]);
let aborts = 0;
+ // When installStrategy29 processes the configured inputs
const runtime = installStrategy29(f.view, {
request: ({ signal }) => new Promise((resolve, reject) => {
signal.addEventListener('abort', () => { aborts += 1; reject(signal.reason); }, { once: true });
@@ -105,9 +118,10 @@ test('hiding the page aborts the remote request and resumes with one shared runt
registerMenuCommand() {},
getGatewayState() { return { available: true, configured: true, settingsRevision: 0 }; },
});
+ // Then user observes that hiding the page aborts the remote request and resumes with one shared runtime timer
assert.equal(runtime.diagnostics.remoteSummary.inFlight, true);
f.hide(true);
- await new Promise(resolve => f.view.setTimeout(resolve, 0));
+ await observeStrategyCondition(() => aborts === 1 && !runtime.diagnostics.remoteSummary.inFlight, 'hidden-page request abort');
assert.equal(aborts, 1);
assert.equal(f.timers.size, 0);
assert.equal(runtime.diagnostics.remoteSummary.contextPresent, true);
@@ -118,14 +132,16 @@ test('hiding the page aborts the remote request and resumes with one shared runt
f.dom.window.close();
});
-test('actual remote client retains rows and cursor across visibility and bootstraps a new route', async () => {
- const f = fixture();
+test('user observes that actual remote client retains rows and cursor across visibility and bootstraps a new route', async (t) => {
+ // Given the standalone Strategy 29 page and runtime dependencies
+ const f = fixture(t);
const values = new Map([
['strategy29GatewayAuthSecret', 'synthetic-secret'],
]);
const urls = [];
const first = { ...gatewayEvents.events[0], symbol: 'BTR/USDT:USDT', sequence: 900 };
const second = { ...gatewayEvents.events[1], symbol: 'BTR/USDT:USDT', sequence: 901 };
+ // When installStrategy29 processes the configured inputs
const runtime = installStrategy29(f.view, {
request: async ({ path: url }) => {
const query = new URL(url, 'https://gateway.invalid');
@@ -142,22 +158,22 @@ test('actual remote client retains rows and cursor across visibility and bootstr
setValue: (key, value) => values.set(key, value),
registerMenuCommand() {}, getGatewayState() { return { available: true, configured: true, settingsRevision: 0 }; },
});
- const settle = () => new Promise(resolve => f.view.setTimeout(resolve, 0));
- await settle();
+ await observeStrategyCondition(() => runtime.diagnostics.remoteSummary.cursor === 900 && !runtime.diagnostics.remoteSummary.inFlight, 'initial remote event render');
const panel = f.view.document.getElementById('jh-strategy29-summary-panel');
+ // Then user observes that actual remote client retains rows and cursor across visibility and bootstraps a new route
assert.equal(urls[0].searchParams.get('mode'), 'latest_per_timeframe');
assert.equal(urls[0].searchParams.get('limit'), '3');
assert.equal(panel.querySelectorAll('[data-role=remote-event]').length, 1);
f.hide(true);
assert.equal(runtime.diagnostics.remoteSummary.cursor, 900);
f.hide(false);
- await settle();
+ await observeStrategyCondition(() => runtime.diagnostics.remoteSummary.cursor === 901 && !runtime.diagnostics.remoteSummary.inFlight, 'resumed remote event render');
assert.equal(f.view.document.getElementById('jh-strategy29-summary-panel'), panel);
assert.equal(urls[1].searchParams.get('cursor'), '900');
assert.equal(runtime.diagnostics.remoteSummary.cursor, 901);
assert.deepEqual([...panel.querySelectorAll('[data-role=remote-event]')].map(row => row.dataset.eventId), [second.event_id, first.event_id]);
f.view.history.pushState({}, '', '/en/futures/ETHUSDT');
- await settle();
+ await observeStrategyCondition(() => runtime.diagnostics.remoteSummary.canonicalSymbol === 'ETH/USDT:USDT' && !runtime.diagnostics.remoteSummary.inFlight, 'replacement route bootstrap');
assert.equal(urls[2].searchParams.get('mode'), 'latest_per_timeframe');
assert.equal(urls[2].searchParams.get('limit'), '3');
assert.equal(urls[2].searchParams.has('cursor'), false);
@@ -168,19 +184,25 @@ test('actual remote client retains rows and cursor across visibility and bootstr
});
for (const failure of ['embedded conflict', 'interval subscription failure']) {
- test(`permanent ${failure} retires the populated remote panel and request`, async () => {
- const f = fixture();
+ test(`user observes that permanent ${failure} retires the populated remote panel and request`, async (t) => {
+ // Given the standalone Strategy 29 page and runtime dependencies
+ const f = fixture(t);
const values = new Map([
['strategy29GatewayAuthSecret', 'synthetic-secret'],
]);
let requests = 0, aborts = 0;
let releaseLate;
+ let lateDelivered = false;
+ // When installStrategy29 processes the configured inputs
const runtime = installStrategy29(f.view, {
request: ({ path: url, signal }) => {
requests += 1;
if (requests > 2) return new Promise(resolve => {
releaseLate = resolve;
signal.addEventListener('abort', () => { aborts += 1; }, { once: true });
+ }).then(response => {
+ lateDelivered = true;
+ return response;
});
const body = url.includes('/status') ? gatewayStatus : {
...gatewayEvents,
@@ -193,10 +215,10 @@ for (const failure of ['embedded conflict', 'interval subscription failure']) {
setValue: (key, value) => values.set(key, value),
registerMenuCommand() {}, getGatewayState() { return { available: true, configured: true, settingsRevision: 0 }; },
});
- const settle = () => new Promise(resolve => f.view.setTimeout(resolve, 0));
try {
- await settle();
+ await observeStrategyCondition(() => runtime.diagnostics.remoteSummary.state === 'connected' && !runtime.diagnostics.remoteSummary.inFlight, 'populated remote panel');
const panel = f.view.document.getElementById('jh-strategy29-summary-panel');
+ // Then user observes that permanent the selected case retires the populated remote panel and request
assert.equal(panel.querySelectorAll('[data-role=remote-event]').length, 1);
assert.equal(runtime.diagnostics.remoteSummary.state, 'connected');
f.hide(true); f.hide(false);
@@ -220,7 +242,7 @@ for (const failure of ['embedded conflict', 'interval subscription failure']) {
root.querySelector('iframe').contentWindow.tradingViewApi = { activeChart: () => chart };
}
f.tick();
- await settle();
+ await observeStrategyCondition(() => runtime.diagnostics.runtimeFailure !== null && !runtime.diagnostics.remoteSummary.contextPresent, 'permanent runtime failure');
assert.match(runtime.diagnostics.runtimeFailure, failure === 'embedded conflict' ? /update Orderbook/ : /synthetic interval subscription failure/);
assert.equal(aborts, 1);
assert.equal(panel.isConnected, false);
@@ -229,7 +251,7 @@ for (const failure of ['embedded conflict', 'interval subscription failure']) {
releaseLate({ status: 200, responseText: JSON.stringify(gatewayStatus) });
f.hide(true); f.hide(false);
f.view.dispatchEvent(new f.view.Event('pageshow'));
- await settle();
+ await observeStrategyCondition(() => lateDelivered, 'retired host response delivered');
assert.equal(requests, 3);
assert.equal(f.view.document.getElementById('jh-strategy29-summary-panel'), null);
assert.equal(f.timers.size, 0);
@@ -241,13 +263,16 @@ for (const failure of ['embedded conflict', 'interval subscription failure']) {
}
for (const legacyFirst of [true, false]) {
- test(`legacy embedded observer refuses coexistence (legacy first=${legacyFirst})`, () => {
- const f = fixture();
+ test(`user observes that legacy embedded observer refuses coexistence (legacy first=${legacyFirst})`, (t) => {
+ // Given the standalone Strategy 29 page and runtime dependencies
+ const f = fixture(t);
const legacy = {};
Object.defineProperty(legacy, 'bollingerAlertState', { get() { throw new Error('Do not inspect legacy runtime data'); } });
if (legacyFirst) f.view.__TM_CLOSE_LONG_DEBUG__ = legacy;
+ // When installStrategy29 processes the configured inputs
const runtime = installStrategy29(f.view);
if (!legacyFirst) { f.view.__TM_CLOSE_LONG_DEBUG__ = legacy; f.tick(); }
+ // Then user observes that legacy embedded observer refuses coexistence (legacy first=the selected case)
assert.match(runtime.diagnostics.runtimeFailure, /update Orderbook to 2.7.199/);
assert.equal(runtime.diagnostics.failed, null);
assert.equal(f.timers.size, 0);
@@ -257,15 +282,18 @@ for (const legacyFirst of [true, false]) {
});
}
-test('invalid shared gateway state remains isolated from the local observer at startup', () => {
- const f = fixture();
+test('user observes that invalid shared gateway state remains isolated from the local observer at startup', (t) => {
+ // Given the standalone Strategy 29 page and runtime dependencies
+ const f = fixture(t);
try {
+ // When installStrategy29 processes the configured inputs
const runtime = installStrategy29(f.view, {
request: async () => { throw new Error('must not request'); },
getValue: (_key, fallback) => fallback,
setValue() {},
getGatewayState() { throw new TypeError('Shared signal gateway state is invalid'); },
});
+ // Then user observes that invalid shared gateway state remains isolated from the local observer at startup
assert.equal(runtime.diagnostics.runtimeFailure, null);
assert.equal(runtime.diagnostics.remoteSummary.state, 'stopped');
assert.equal(runtime.diagnostics.remoteSummary.lastError, 'Shared signal gateway state is invalid');
@@ -277,11 +305,13 @@ test('invalid shared gateway state remains isolated from the local observer at s
} finally { f.dom.window.close(); }
});
-test('a failed provider retires an active remote request and does not retry while local sampling continues', async () => {
- const f = fixture();
+test('user observes that a failed provider retires an active remote request and does not retry while local sampling continues', async (t) => {
+ // Given the standalone Strategy 29 page and runtime dependencies
+ const f = fixture(t);
let invalid = false;
let stateReads = 0;
let requestSignal;
+ // When installStrategy29 processes the configured inputs
const runtime = installStrategy29(f.view, {
request: ({ signal }) => new Promise((_resolve, reject) => {
requestSignal = signal;
@@ -295,10 +325,11 @@ test('a failed provider retires an active remote request and does not retry whil
return { available: true, configured: true, settingsRevision: 0 };
},
});
+ // Then user observes that a failed provider retires an active remote request and does not retry while local sampling continues
assert.equal(f.view.document.querySelectorAll('#jh-strategy29-summary-panel').length, 1);
invalid = true;
f.tick();
- await new Promise(resolve => setImmediate(resolve));
+ await observeStrategyCondition(() => requestSignal.aborted && runtime.diagnostics.remoteSummary.state === 'stopped' && !runtime.diagnostics.remoteSummary.inFlight, 'failed provider request retirement');
assert.equal(requestSignal.aborted, true);
assert.equal(f.view.document.querySelectorAll('#jh-strategy29-summary-panel').length, 0);
assert.equal(runtime.diagnostics.remoteSummary.state, 'stopped');
@@ -310,3 +341,126 @@ test('a failed provider retires an active remote request and does not retry whil
assert.equal(f.view.document.querySelectorAll('#jh-strategy29-summary-error').length, 0);
f.dom.window.close();
});
+
+test('user pauses for the browser back-forward cache and resumes exactly one native timer', (t) => {
+ // Given an active runtime owns one real browser interval under the test clock
+ const f = fixture(t);
+ const runtime = installStrategy29(f.view);
+ t.after(() => { runtime.dispose(); f.dom.window.close(); });
+ const originalTimer = [...f.timers.keys()][0];
+
+ // When the browser stores the page in its back-forward cache
+ f.view.dispatchEvent(new f.view.PageTransitionEvent('pagehide', { persisted: true }));
+ f.advance(5000);
+
+ // Then sampling is paused without permanently disposing the runtime
+ assert.equal(runtime.diagnostics.disposed, false);
+ assert.equal(runtime.diagnostics.timerRunning, false);
+ assert.equal(f.timers.size, 0);
+
+ // When the browser restores the cached page and repeats its pageshow notification
+ f.view.dispatchEvent(new f.view.PageTransitionEvent('pageshow', { persisted: true }));
+ f.view.dispatchEvent(new f.view.PageTransitionEvent('pageshow', { persisted: true }));
+
+ // Then exactly one fresh interval resumes with the declared one-second cadence
+ assert.equal(runtime.diagnostics.disposed, false);
+ assert.equal(runtime.diagnostics.timerRunning, true);
+ assert.equal(f.timers.size, 1);
+ assert.notEqual([...f.timers.keys()][0], originalTimer);
+ assert.deepEqual([...f.timers.values()], [{ milliseconds: 1000 }]);
+});
+
+test('user permanently disposes observation when pagehide is not persisted', (t) => {
+ // Given the active page contains a runtime timer and its upgrade notice
+ const f = fixture(t);
+ const runtime = installStrategy29(f.view);
+ t.after(() => { runtime.dispose(); f.dom.window.close(); });
+ assert.equal(f.view.document.querySelectorAll('#jh-strategy29-client-upgrade').length, 1);
+
+ // When the browser leaves permanently and later dispatches stale lifecycle events
+ f.view.dispatchEvent(new f.view.PageTransitionEvent('pagehide', { persisted: false }));
+ f.view.dispatchEvent(new f.view.PageTransitionEvent('pageshow', { persisted: false }));
+ f.hide(true);
+ f.hide(false);
+ f.view.history.pushState({}, '', '/en/futures/ETHUSDT');
+ f.advance(3000);
+
+ // Then neither the timer nor the removed presentation can be resurrected
+ assert.equal(runtime.diagnostics.disposed, true);
+ assert.equal(runtime.diagnostics.timerRunning, false);
+ assert.equal(f.timers.size, 0);
+ assert.equal(f.view.document.querySelectorAll('#jh-strategy29-client-upgrade').length, 0);
+ assert.equal(f.view.document.querySelectorAll('#jh-strategy29-bollinger-status').length, 0);
+});
+
+test('user defers hidden-page route sampling until visibility returns', (t) => {
+ // Given injection begins while the native document is hidden
+ const f = fixture(t);
+ f.setHidden(true);
+ const runtime = installStrategy29(f.view);
+ t.after(() => { runtime.dispose(); f.dom.window.close(); });
+
+ // When a hidden route transition and pageshow occur before visibility returns
+ f.view.history.pushState({}, '', '/zh-CN/futures/ETHUSDT');
+ f.view.dispatchEvent(new f.view.PageTransitionEvent('pageshow', { persisted: true }));
+ f.advance(3000);
+
+ // Then hidden work neither installs a timer nor mounts route-specific presentation
+ assert.equal(f.timers.size, 0);
+ assert.equal(runtime.diagnostics.timerRunning, false);
+ assert.equal(f.view.document.querySelectorAll('#jh-strategy29-client-upgrade').length, 0);
+
+ // When the actual visibility-change event reports the page visible
+ f.hide(false);
+
+ // Then the current route is sampled and one shared timer starts
+ assert.equal(f.timers.size, 1);
+ assert.equal(runtime.diagnostics.timerRunning, true);
+ assert.equal(f.view.document.querySelectorAll('#jh-strategy29-client-upgrade').length, 1);
+});
+
+test('user sees a stopped-runtime notice restored after the host replaces its DOM', (t) => {
+ // Given a detected embedded observer has permanently stopped the new runtime
+ const f = fixture(t);
+ f.view.__TM_CLOSE_LONG_DEBUG__ = { bollingerAlertState: {} };
+ const runtime = installStrategy29(f.view);
+ t.after(() => { runtime.dispose(); f.dom.window.close(); });
+ const notice = f.view.document.getElementById('jh-strategy29-bollinger-status');
+ const originalText = notice.textContent;
+ const originalFailure = runtime.diagnostics.runtimeFailure;
+ notice.remove();
+
+ // When the host's next route transition samples the still-stopped runtime
+ f.view.history.pushState({}, '', '/zh-CN/futures/BTRUSDT');
+ const restored = f.view.document.getElementById('jh-strategy29-bollinger-status');
+
+ // Then the failure remains visible in the route language without restarting observation
+ assert.notEqual(restored, notice);
+ assert.equal(restored.getAttribute('role'), 'status');
+ assert.notEqual(restored.textContent, originalText);
+ assert.match(restored.textContent, /2\.7\.199/);
+ assert.equal(runtime.diagnostics.runtimeFailure, originalFailure);
+ assert.equal(f.view.document.querySelectorAll('#jh-strategy29-bollinger-status').length, 1);
+ assert.equal(f.timers.size, 0);
+});
+
+test('user sees an early runtime failure when the native document body becomes available', (t) => {
+ // Given document-start injection detects a conflict before the body exists
+ const f = fixture(t);
+ f.view.document.body.remove();
+ f.view.__TM_CLOSE_LONG_DEBUG__ = { bollingerAlertState: {} };
+ const runtime = installStrategy29(f.view);
+ t.after(() => { runtime.dispose(); f.dom.window.close(); });
+ assert.equal(f.view.document.getElementById('jh-strategy29-bollinger-status'), null);
+
+ // When the real document lifecycle exposes its body
+ f.view.document.documentElement.append(f.view.document.createElement('body'));
+ f.view.document.dispatchEvent(new f.view.Event('DOMContentLoaded'));
+
+ // Then the retained failure is presented once and sampling remains stopped
+ const notice = f.view.document.getElementById('jh-strategy29-bollinger-status');
+ assert.match(notice.textContent, /update Orderbook to 2\.7\.199/);
+ assert.equal(notice.getAttribute('role'), 'status');
+ assert.equal(f.view.document.querySelectorAll('#jh-strategy29-bollinger-status').length, 1);
+ assert.equal(f.timers.size, 0);
+});
diff --git a/test/dom/binance-strategy29-bollinger/strategy29-summary-panel.test.js b/test/dom/binance-strategy29-bollinger/strategy29-summary-panel.test.js
index e2d18ae..51abc00 100644
--- a/test/dom/binance-strategy29-bollinger/strategy29-summary-panel.test.js
+++ b/test/dom/binance-strategy29-bollinger/strategy29-summary-panel.test.js
@@ -13,17 +13,20 @@ function createStrategy29SummaryPanel(document, symbol, options = {}) {
const status = JSON.parse(await readFile(new URL('../../fixtures/strategy29-gateway-status.json', import.meta.url)));
const events = JSON.parse(await readFile(new URL('../../fixtures/strategy29-gateway-events.json', import.meta.url)));
-test('each timeframe retains three signals through dense minute updates and historical backfills', () => {
+test('user observes that each timeframe retains three signals through dense minute updates and historical backfills', () => {
+ // Given the remote summary panel and observer snapshot
const dom = new JSDOM('');
const panel = createStrategy29SummaryPanel(dom.window.document, 'BTC/USDT:USDT');
const timeframes = ['1m', '5m', '15m', '1h', '4h', '1d'];
let sequence = 0;
+ // When timeframes.flatMap processes the configured inputs
const records = timeframes.flatMap((timeframe, group) => Array.from({ length: group === 0 ? 30 : 3 }, (_, index) => ({
...events.events[0], timeframe, event_id: String(++sequence).padStart(64, '0'), sequence,
bar_close_ms: events.observed_at_ms - group * 86_400_000 - index * 60_000,
})));
panel.addEvents(records, events.observed_at_ms);
const rows = () => [...dom.window.document.querySelectorAll('[data-role=remote-event]')];
+ // Then user observes that each timeframe retains three signals through dense minute updates and historical backfills
assert.equal(panel.size, 18);
for (const timeframe of timeframes) assert.equal(rows().filter(row => row.firstChild.textContent === timeframe).length, 3);
const otherIds = rows().filter(row => row.firstChild.textContent !== '1m').map(row => row.dataset.eventId);
@@ -41,14 +44,17 @@ test('each timeframe retains three signals through dense minute updates and hist
dom.window.close();
});
-test('diagnostics start collapsed with duration-sorted processing while actionable notices stay outside', () => {
+test('user observes that diagnostics start collapsed with duration-sorted processing while actionable notices stay outside', () => {
+ // Given the remote summary panel and observer snapshot
const dom = new JSDOM('');
const panel = createStrategy29SummaryPanel(dom.window.document, 'BTC/USDT:USDT');
const timeframes = ['15m', '1d', '1h', '1m', '4h', '5m'];
+ // When panel.renderStatus processes the configured inputs
panel.renderStatus({ ...status, universe: { ...status.universe, configured_timeframes: timeframes },
units: timeframes.map(timeframe => ({ ...status.units[0], timeframe, status: timeframe === '4h' ? 'data_gap' : 'ready', reason: timeframe === '4h' ? 'closed_bar_gap' : 'current' })),
});
const diagnostics = dom.window.document.querySelector('[data-role=diagnostics]');
+ // Then user observes that diagnostics start collapsed with duration-sorted processing while actionable notices stay outside
assert.equal(diagnostics.tagName, 'DETAILS');
assert.equal(diagnostics.open, false);
for (const role of ['spec', 'reference', 'units', 'delivery', 'selection-details']) {
@@ -69,13 +75,15 @@ test('diagnostics start collapsed with duration-sorted processing while actionab
dom.window.close();
});
-test('empty increments retain event DOM identities while advancing freshness', () => {
+test('user observes that empty increments retain event DOM identities while advancing freshness', () => {
+ // Given the remote summary panel and observer snapshot
const dom = new JSDOM('');
const panel = createStrategy29SummaryPanel(dom.window.document, 'BTC/USDT:USDT');
const incoming = Array.from({ length: 20 }, (_, index) => ({
...events.events[0], event_id: `performance-${index}`, sequence: index + 1,
bar_close_ms: events.events[0].bar_close_ms + index * 60_000,
}));
+ // When panel.addEvents processes the configured inputs
panel.addEvents(incoming, events.observed_at_ms);
const container = dom.window.document.querySelector('[data-role=events]');
const rows = [...container.children];
@@ -84,6 +92,7 @@ test('empty increments retain event DOM identities while advancing freshness', (
const observer = new dom.window.MutationObserver(() => {});
observer.observe(container, { childList: true, subtree: true, characterData: true });
for (let index = 1; index <= 10; index += 1) panel.addEvents([], events.observed_at_ms + index * 5_000);
+ // Then user observes that empty increments retain event DOM identities while advancing freshness
assert.equal(container.children.length, rows.length);
rows.forEach((row, index) => assert.equal(container.children[index], row));
assert.equal(observer.takeRecords().length, 0);
@@ -98,11 +107,14 @@ test('empty increments retain event DOM identities while advancing freshness', (
});
for (const state of ['module_disabled', 'gateway_unavailable', 'unavailable']) {
- test(`${state} removes current readiness while preserving historical signals across locale changes`, () => {
+ test(`user observes that ${state} removes current readiness while preserving historical signals across locale changes`, () => {
+ // Given the remote summary panel and observer snapshot
const dom = new JSDOM('');
const panel = createStrategy29SummaryPanel(dom.window.document, 'BTC/USDT:USDT');
+ // When panel.renderStatus processes the configured inputs
panel.renderStatus(status);
panel.addEvents(events.events, events.observed_at_ms);
+ // Then user observes that the selected case removes current readiness while preserving historical signals across locale changes
assert.equal(dom.window.document.querySelectorAll('[data-role=unit]').length, 2);
panel.setConnection(state, { zhCN: '暂不可用', en: 'Unavailable' });
assert.equal(dom.window.document.querySelectorAll('[data-role=unit]').length, 0);
@@ -119,12 +131,15 @@ for (const state of ['module_disabled', 'gateway_unavailable', 'unavailable']) {
});
}
-test('distinguishes stored processing success from current live readiness', () => {
+test('user distinguishes stored processing success from current live readiness', () => {
+ // Given the remote summary panel and observer snapshot
const dom = new JSDOM('');
const panel = createStrategy29SummaryPanel(dom.window.document, 'BTC/USDT:USDT');
+ // When panel.renderStatus processes the configured inputs
panel.renderStatus({ ...status, universe: {
...status.universe, ready_unit_count: 0, pending_unit_count: status.universe.selected_unit_count,
} });
+ // Then user distinguishes stored processing success from current live readiness
assert.match(dom.window.document.querySelector('[data-role=selection-details]').textContent, /0\/3 live units ready/);
assert.match(dom.window.document.querySelector('[data-role=notices]').textContent, /3 server monitoring units are not ready/);
assert.match(dom.window.document.body.textContent, /Last processing status/);
@@ -136,11 +151,14 @@ test('distinguishes stored processing success from current live readiness', () =
dom.window.close();
});
-test('distinguishes unavailable selection, unselected symbol and pending unit registration', () => {
+test('user distinguishes unavailable selection, unselected symbol and pending unit registration', () => {
+ // Given the remote summary panel and observer snapshot
const dom = new JSDOM('');
const panel = createStrategy29SummaryPanel(dom.window.document, 'BTC/USDT:USDT');
+ // When panel.addEvents processes the configured inputs
panel.addEvents(events.events);
panel.renderStatus({ ...status, units: [] });
+ // Then user distinguishes unavailable selection, unselected symbol and pending unit registration
assert.match(dom.window.document.body.textContent, /Symbol is selected; waiting for unit status/);
assert.doesNotMatch(dom.window.document.body.textContent, /Symbol is not watched/);
panel.renderStatus({ ...status, universe: {
@@ -158,11 +176,14 @@ test('distinguishes unavailable selection, unselected symbol and pending unit re
dom.window.close();
});
-test('replaces dynamic membership while retaining durable signal history', () => {
+test('user observes that replaces dynamic membership while retaining durable signal history', () => {
+ // Given the remote summary panel and observer snapshot
const dom = new JSDOM('');
const panel = createStrategy29SummaryPanel(dom.window.document, 'BTC/USDT:USDT');
+ // When panel.renderStatus processes the configured inputs
panel.renderStatus(status);
panel.addEvents(events.events);
+ // Then user observes that replaces dynamic membership while retaining durable signal history
assert.equal(dom.window.document.querySelectorAll('[data-role=unit]').length, 2);
panel.renderStatus({ ...status, universe: { ...status.universe, configured_timeframes: ['1h'] } });
assert.deepEqual([...dom.window.document.querySelectorAll('[data-role=unit]')].map(row => row.firstChild.textContent), ['1h']);
@@ -180,11 +201,14 @@ test('replaces dynamic membership while retaining durable signal history', () =>
dom.window.close();
});
-test('renders all watched timeframes for the route symbol and labels global delivery totals', () => {
+test('user renders all watched timeframes for the route symbol and labels global delivery totals', () => {
+ // Given the remote summary panel and observer snapshot
const dom = new JSDOM('');
const panel = createStrategy29SummaryPanel(dom.window.document, 'BTC/USDT:USDT');
+ // When panel.renderStatus processes the configured inputs
panel.renderStatus(status);
const text = dom.window.document.body.textContent;
+ // Then user renders all watched timeframes for the route symbol and labels global delivery totals
assert.match(text, /BTC\/USDT:USDT/);
assert.match(text, /1m/);
assert.match(text, /1h/);
@@ -198,11 +222,14 @@ test('renders all watched timeframes for the route symbol and labels global deli
dom.window.close();
});
-test('shows multi-timeframe events, deduplicates identities and clears only remote rows', () => {
+test('user sees multi-timeframe events with deduplicated identities and independently cleared remote rows', () => {
+ // Given the remote summary panel and observer snapshot
const dom = new JSDOM('');
const panel = createStrategy29SummaryPanel(dom.window.document, 'BTC/USDT:USDT');
+ // When panel.addEvents processes the configured inputs
panel.addEvents(events.events, events.observed_at_ms);
panel.addEvents([events.events[0]]);
+ // Then user sees multi-timeframe events with deduplicated identities and independently cleared remote rows
assert.equal(dom.window.document.querySelectorAll('[data-role=remote-event]').length, 2);
const text = dom.window.document.body.textContent;
assert.match(text, /1m/);
@@ -218,12 +245,15 @@ test('shows multi-timeframe events, deduplicates identities and clears only remo
dom.window.close();
});
-test('makes server/local spec mismatch visible without rendering it as verified', () => {
+test('user observes that makes server/local spec mismatch visible without rendering it as verified', () => {
+ // Given the remote summary panel and observer snapshot
const dom = new JSDOM('');
const panel = createStrategy29SummaryPanel(dom.window.document, 'BTC/USDT:USDT');
+ // When panel.renderStatus processes the configured inputs
panel.renderStatus(status);
panel.addEvents(events.events, events.observed_at_ms);
panel.renderStatus({ schema_version: 1, spec_version: 'other_spec', observed_at_ms: status.observed_at_ms });
+ // Then user observes that makes server/local spec mismatch visible without rendering it as verified
assert.match(dom.window.document.body.textContent, /Spec mismatch/);
assert.equal(dom.window.document.querySelector('[data-role=spec]').dataset.state, 'error');
assert.equal(dom.window.document.querySelectorAll('[data-role=unit]').length, 0);
@@ -235,15 +265,18 @@ test('makes server/local spec mismatch visible without rendering it as verified'
dom.window.close();
});
-test('retains newest signal close times regardless of insertion or detection order', () => {
+test('user retains newest signal close times regardless of insertion or detection order', () => {
+ // Given the remote summary panel and observer snapshot
const dom = new JSDOM('');
const panel = createStrategy29SummaryPanel(dom.window.document, 'BTC/USDT:USDT');
const first = { ...events.events[0], event_id: 'a'.repeat(64), sequence: 10, detected_at_ms: 3000, bar_close_ms: 3000 };
const second = { ...events.events[0], event_id: 'b'.repeat(64), sequence: 11, detected_at_ms: 2000, bar_close_ms: 3000 };
const third = { ...events.events[0], event_id: 'c'.repeat(64), sequence: 12, detected_at_ms: 4000, bar_close_ms: 2000 };
const fourth = { ...events.events[0], event_id: 'd'.repeat(64), sequence: 13, detected_at_ms: 5000, bar_close_ms: 1000 };
+ // When panel.addEvents processes the configured inputs
panel.addEvents([first, second, third]);
panel.addEvents([fourth]);
+ // Then user retains newest signal close times regardless of insertion or detection order
assert.deepEqual([...dom.window.document.querySelectorAll('[data-role=remote-event]')].map(row => row.dataset.eventId), [second.event_id, first.event_id, third.event_id]);
panel.destroy();
dom.window.close();
diff --git a/test/dom/binance-strategy29-bollinger/summary-locale-position.test.js b/test/dom/binance-strategy29-bollinger/summary-locale-position.test.js
index 45cc438..1408bc0 100644
--- a/test/dom/binance-strategy29-bollinger/summary-locale-position.test.js
+++ b/test/dom/binance-strategy29-bollinger/summary-locale-position.test.js
@@ -1,5 +1,6 @@
import assert from 'node:assert/strict';
import test from 'node:test';
+import { captureStrategyError } from '../../helpers/strategy-migration-boundaries.js';
import { readFile } from 'node:fs/promises';
import { JSDOM } from 'jsdom';
import { SUMMARY_COPY } from '../../../src/binance-strategy29-bollinger/ui-copy.js';
@@ -28,11 +29,14 @@ function fixture(locale = 'zh-CN', stored = { left: 100, top: 120 }) {
return { dom, controller, panel, header, captured, fire, saves, close };
}
-test('Chinese panel translates retained status and signals and switches to English without losing rows', () => {
+test('user observes that Chinese panel translates retained status and signals and switches to English without losing rows', () => {
+ // Given the panel locale, viewport and saved coordinates
const f = fixture();
try {
+ // When f.controller.renderStatus processes the configured inputs
f.controller.renderStatus(status);
f.controller.addEvents(events.events, events.observed_at_ms);
+ // Then user observes that Chinese panel translates retained status and signals and switches to English without losing rows
assert.match(f.panel.textContent, /Strategy 29 汇总/);
assert.match(f.panel.textContent, /最近处理状态/);
assert.match(f.panel.textContent, /看跌预警/);
@@ -51,13 +55,16 @@ test('Chinese panel translates retained status and signals and switches to Engli
} finally { f.close(); }
});
-test('header drag restores, clamps and saves position while buttons and destroyed panels never drag', () => {
+test('user observes that header drag restores, clamps and saves position while buttons and destroyed panels never drag', () => {
+ // Given the panel locale, viewport and saved coordinates
const f = fixture();
try {
Object.defineProperties(f.dom.window, { innerWidth: { value: 500, configurable: true }, innerHeight: { value: 400, configurable: true } });
f.panel.getBoundingClientRect = () => ({ left: parseFloat(f.panel.style.left), top: parseFloat(f.panel.style.top), width: 340, height: 200 });
+ // When f.panel.querySelector processes the configured inputs
const header = f.panel.querySelector('header');
const { fire } = f;
+ // Then user observes that header drag restores, clamps and saves position while buttons and destroyed panels never drag
assert.equal(f.panel.style.left, '100px');
assert.equal(f.panel.style.top, '120px');
fire(header, 'pointerdown', 120, 130);
@@ -81,8 +88,9 @@ test('header drag restores, clamps and saves position while buttons and destroye
} finally { f.close(); }
});
-test('drag ignores other pointers and saves once on cancel, capture loss or blur', () => {
- for (const ending of ['pointercancel', 'lostpointercapture', 'blur']) {
+for (const ending of ['pointercancel', 'lostpointercapture', 'blur']) {
+ test(`user observes that drag ignores other pointers and saves once on cancel, capture loss or blur (ending=${JSON.stringify(ending)})`, () => {
+ // Given the panel locale, viewport and saved coordinates
const f = fixture();
try {
f.panel.getBoundingClientRect = () => ({ left: parseFloat(f.panel.style.left), top: parseFloat(f.panel.style.top), width: 340, height: 200 });
@@ -90,10 +98,12 @@ test('drag ignores other pointers and saves once on cancel, capture loss or blur
f.fire(f.header, 'pointerdown', 120, 130, overrides);
assert.equal(f.captured.size, 0);
}
+ // When f.fire processes the configured inputs
f.fire(f.header, 'pointerdown', 120, 130);
f.fire(f.header, 'pointerdown', 900, 900, { pointerId: 2 });
f.fire(f.header, 'pointermove', 800, 800, { pointerId: 2 });
f.fire(f.header, 'pointerup', 800, 800, { pointerId: 2 });
+ // Then user observes that drag ignores other pointers and saves once on cancel, capture loss or blur (ending=the selected case)
assert.equal(f.panel.style.left, '100px');
assert.deepEqual(f.saves, []);
f.fire(f.header, 'pointermove', 180, 170);
@@ -110,16 +120,20 @@ test('drag ignores other pointers and saves once on cancel, capture loss or blur
assert.equal(f.panel.style.left, '160px');
assert.equal(f.panel.style.top, '160px');
} finally { f.close(); }
- }
-});
-test('resize and content growth keep the panel visible, including collapse/expand and locale rerender', () => {
+ });
+}
+
+test('user observes that resize and content growth keep the panel visible, including collapse/expand and locale rerender', () => {
+ // Given the panel locale, viewport and saved coordinates
const f = fixture('en', { left: 900, top: 600 });
try {
let height = 200;
f.panel.getBoundingClientRect = () => ({ left: parseFloat(f.panel.style.left), top: parseFloat(f.panel.style.top), width: 340, height: f.panel.querySelector('[data-role=body]').style.display === 'none' ? 40 : height });
Object.defineProperties(f.dom.window, { innerWidth: { value: 500, configurable: true }, innerHeight: { value: 400, configurable: true } });
+ // When f.dom.window.dispatchEvent processes the configured inputs
f.dom.window.dispatchEvent(new f.dom.window.Event('resize'));
+ // Then user observes that resize and content growth keep the panel visible, including collapse/expand and locale rerender
assert.equal(f.panel.style.left, '160px');
assert.equal(f.panel.style.top, '200px');
height = 300;
@@ -138,21 +152,28 @@ test('resize and content growth keep the panel visible, including collapse/expan
} finally { f.close(); }
});
-test('invalid persisted positions fail explicitly before installing a panel', () => {
+test('user observes that invalid persisted positions fail explicitly before installing a panel', () => {
+ // Given a persisted position whose horizontal coordinate is not numeric
const dom = new JSDOM('');
try {
- assert.throws(() => createStrategy29SummaryPanel(dom.window.document, 'BTC/USDT:USDT', {
+ // When the summary panel loads those persisted coordinates
+ const failure = captureStrategyError(() => createStrategy29SummaryPanel(dom.window.document, 'BTC/USDT:USDT', {
loadPosition: () => ({ left: 'bad', top: 10 }), savePosition() {},
- }), /position is invalid/);
+ }));
+ // Then the invalid position is reported without installing a panel
+ assert.match(failure.message, /position is invalid/);
assert.equal(dom.window.document.getElementById('jh-strategy29-summary-panel'), null);
} finally { dom.window.close(); }
});
-test('configuration and error states rerender in the chosen language without clearing diagnostics', () => {
+test('user observes that configuration and error states rerender in the chosen language without clearing diagnostics', () => {
+ // Given the panel locale, viewport and saved coordinates
const f = fixture('en');
try {
+ // When f.controller.setConnection processes the configured inputs
f.controller.setConnection('configuration_required', SUMMARY_COPY.configuration);
+ // Then user observes that configuration and error states rerender in the chosen language without clearing diagnostics
assert.equal(f.panel.querySelector('[data-role=connection]').textContent, 'Gateway secret is not configured');
f.controller.setLocale('zh-CN');
assert.equal(f.panel.querySelector('[data-role=connection]').textContent, '尚未配置网关密钥');
diff --git a/test/dom/binance-strategy29-bollinger/summary-runtime-boundaries.test.js b/test/dom/binance-strategy29-bollinger/summary-runtime-boundaries.test.js
new file mode 100644
index 0000000..2b45205
--- /dev/null
+++ b/test/dom/binance-strategy29-bollinger/summary-runtime-boundaries.test.js
@@ -0,0 +1,249 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import test from 'node:test';
+import { createStrategy29RemoteSummary, STRATEGY29_PANEL_POSITION_KEY } from '../../../src/binance-strategy29-bollinger/remote-summary.js';
+import { createStrategy29SummaryPanel } from '../../../src/binance-strategy29-bollinger/dom/strategy29-summary-panel.js';
+import {
+ validateStrategy29EventsResponse, validateStrategy29StatusResponse,
+} from '../../../src/binance-strategy29-bollinger/core/remote-summary-contract.js';
+import { createStrategy29ChartHost, createStrategy29RequestHost } from '../../helpers/strategy29-runtime-boundary-host.js';
+import { installStrategyClock, observeStrategyCondition } from '../../helpers/strategy-migration-boundaries.js';
+
+const status = JSON.parse(await readFile(new URL('../../fixtures/strategy29-gateway-status.json', import.meta.url)));
+const events = JSON.parse(await readFile(new URL('../../fixtures/strategy29-gateway-events.json', import.meta.url)));
+const initialMissingSelection = {
+ ...status, units: [], universe: {
+ ...status.universe, generation: null, refresh_status: 'fail_closed', reason: 'missing_current_universe_facts',
+ selected_markets: [], configured_timeframes: [], selected_unit_count: 0, ready_unit_count: 0, pending_unit_count: 0,
+ refreshed_at_ms: null, last_successful_refreshed_at_ms: null, last_success_age_seconds: null,
+ last_refresh_error_at_ms: null, selection_expires_at_ms: null,
+ },
+};
+
+function remoteFixture(t) {
+ const host = createStrategy29ChartHost();
+ host.dom.reconfigure({ url: 'https://www.binance.com/en/futures/BTCUSDT' });
+ const clock = installStrategyClock(t, host.view, status.observed_at_ms);
+ const gateway = createStrategy29RequestHost();
+ const values = new Map([[STRATEGY29_PANEL_POSITION_KEY, { left: 120, top: 80 }]]);
+ const writes = [];
+ const remote = createStrategy29RemoteSummary({
+ view: host.view,
+ request: options => gateway.request(options),
+ getValue: (key, defaultValue) => values.has(key) ? values.get(key) : defaultValue,
+ setValue: (key, value) => { values.set(key, value); writes.push({ key, value }); },
+ getGatewayState: () => ({ available: true, configured: true, settingsRevision: 1 }),
+ });
+ t.after(() => { remote.dispose(); host.close(); });
+ return { host, clock, gateway, remote, writes, panel: () => host.document.getElementById('jh-strategy29-summary-panel') };
+}
+
+test('user replaces the remote context with a fresh latest snapshot after restart', async (t) => {
+ // Given a real remote client and panel containing an acknowledged snapshot.
+ const fixture = remoteFixture(t);
+ fixture.gateway.respond(status);
+ fixture.gateway.respond(events);
+ await fixture.remote.sample();
+ const previous = fixture.panel();
+ const previousSignal = fixture.gateway.requests[0].signal;
+ fixture.gateway.respond(status);
+ fixture.gateway.respond({ ...events, events: [events.events[0]], next_cursor: 90 });
+
+ // When the public restart hook retires the old context and polls immediately.
+ fixture.remote.restart();
+ await observeStrategyCondition(() => !fixture.remote.diagnostics.inFlight, 'restarted remote poll completes');
+
+ // Then the old request owner and panel are retired and a bounded latest query establishes new history.
+ assert.equal(previous.isConnected, false);
+ assert.equal(previousSignal.aborted, true);
+ assert.equal(fixture.panel() === previous, false);
+ assert.deepEqual([...fixture.panel().querySelectorAll('[data-role=remote-event]')].map(row => row.dataset.eventId), [events.events[0].event_id]);
+ assert.equal(new URL(fixture.gateway.requests[3].path, 'https://gateway.invalid').searchParams.get('mode'), 'latest_per_timeframe');
+ assert.equal(fixture.remote.diagnostics.cursor, 90);
+ assert.equal(fixture.remote.diagnostics.state, 'connected');
+ assert.equal(fixture.panel().style.left, '120px');
+ assert.deepEqual(fixture.writes, []);
+});
+
+test('user sees expired retained rows cleared before the replacement latest snapshot arrives', async (t) => {
+ // Given accepted remote history whose next incremental cursor has expired.
+ const fixture = remoteFixture(t);
+ fixture.gateway.respond(status);
+ fixture.gateway.respond(events);
+ await fixture.remote.sample();
+ fixture.gateway.respond(status);
+ fixture.gateway.respond({ schema_version: 1, error: 'cursor_expired', oldest_cursor: 50 }, 409);
+ const latest = fixture.gateway.hold();
+
+ // When the real client resets its cursor and awaits the replacement latest response.
+ const pending = fixture.remote.sample(status.observed_at_ms + 5000);
+ await latest.entered;
+
+ // Then the existing panel drops expired rows and reports that events have not yet been checked.
+ assert.equal(fixture.remote.diagnostics.cursor, null);
+ assert.equal(fixture.panel().querySelectorAll('[data-role=remote-event]').length, 0);
+ assert.equal(fixture.panel().querySelector('[data-role=events-freshness]').textContent, 'Events not checked');
+ assert.equal(new URL(fixture.gateway.requests[4].path, 'https://gateway.invalid').searchParams.get('mode'), 'latest_per_timeframe');
+
+ // When the replacement latest snapshot delivers one newer signal.
+ const replacement = { ...events.events[0], sequence: 70, event_id: 'c'.repeat(64) };
+ latest.respond({ ...events, events: [replacement], next_cursor: 70 });
+ await pending;
+
+ // Then only that replacement signal is shown and its cursor is committed.
+ assert.deepEqual([...fixture.panel().querySelectorAll('[data-role=remote-event]')].map(row => row.dataset.eventId), [replacement.event_id]);
+ assert.equal(fixture.remote.diagnostics.cursor, 70);
+ assert.equal(fixture.remote.diagnostics.state, 'connected');
+});
+
+test('user sees more-history status after two bounded incremental pages without a third events request', async (t) => {
+ // Given a real client with an established global cursor and additional retained history.
+ const fixture = remoteFixture(t);
+ fixture.gateway.respond(status);
+ fixture.gateway.respond({ ...events, events: [], next_cursor: 40 });
+ await fixture.remote.sample();
+ fixture.gateway.respond(status);
+ fixture.gateway.respond({ ...events, events: [events.events[0]], next_cursor: 41, has_more: true });
+ fixture.gateway.respond({ ...events, events: [events.events[1]], next_cursor: 42, has_more: true });
+
+ // When the next public sample consumes its two allowed pages.
+ await fixture.remote.sample(status.observed_at_ms + 5000);
+
+ // Then the panel exposes pending history and the poll stops at the configured page bound.
+ assert.equal(fixture.panel().querySelector('[data-role=connection]').textContent, 'Connected · more history pending');
+ assert.deepEqual(fixture.remote.diagnostics.lastResult, { state: 'connected', pages: 2, hasMore: true });
+ assert.equal(fixture.remote.diagnostics.cursor, 42);
+ assert.equal(fixture.gateway.requests.length, 5);
+ assert.equal(fixture.gateway.remaining, 0);
+ assert.equal(fixture.panel().querySelectorAll('[data-role=remote-event]').length, 2);
+});
+
+test('user removes the remote panel after leaving futures and rejects a late native response without affecting chart drawings', async (t) => {
+ // Given retained remote rows, an unrelated chart drawing and a pending incremental response.
+ const fixture = remoteFixture(t);
+ fixture.host.addForeignShape('user-line');
+ fixture.gateway.respond(status);
+ fixture.gateway.respond(events);
+ await fixture.remote.sample();
+ const oldPanel = fixture.panel();
+ fixture.gateway.respond(status);
+ const late = fixture.gateway.hold();
+ const pending = fixture.remote.sample(status.observed_at_ms + 5000);
+ await late.entered;
+ const oldSignal = fixture.gateway.requests.at(-1).signal;
+
+ // When browser navigation leaves futures before the response completes.
+ fixture.host.view.history.pushState({}, '', '/en/markets');
+ await fixture.remote.sample(status.observed_at_ms + 10_000);
+ late.respond({ ...events, events: [{ ...events.events[0], sequence: 80, event_id: 'd'.repeat(64) }], next_cursor: 80 });
+ await pending;
+
+ // Then the retired response has no page target or cursor to mutate and native drawings remain intact.
+ assert.equal(oldSignal.aborted, true);
+ assert.equal(oldPanel.isConnected, false);
+ assert.equal(fixture.panel(), null);
+ assert.equal(fixture.remote.diagnostics.contextPresent, false);
+ assert.equal(fixture.remote.diagnostics.cursor, null);
+ assert.equal(fixture.remote.diagnostics.state, 'waiting_for_route');
+ assert.deepEqual(fixture.host.chart.getAllShapes(), [{ id: 'user-line', name: 'trend_line' }]);
+ assert.deepEqual(fixture.host.removed, []);
+});
+
+test('user pauses hidden remote samples and cannot restart a disposed panel', async (t) => {
+ // Given a real controller on a hidden page before its first request.
+ const fixture = remoteFixture(t);
+ fixture.host.setHidden(true);
+
+ // When the controller is sampled while hidden and then disposed and restarted.
+ await fixture.remote.sample();
+ fixture.remote.dispose();
+ fixture.host.setHidden(false);
+ fixture.remote.restart();
+ await fixture.remote.sample();
+ fixture.remote.dispose();
+
+ // Then no request or replacement panel can escape either lifecycle boundary.
+ assert.deepEqual(fixture.gateway.requests, []);
+ assert.equal(fixture.panel(), null);
+ assert.equal(fixture.remote.diagnostics.contextPresent, false);
+ assert.equal(fixture.remote.diagnostics.inFlight, false);
+ assert.deepEqual(fixture.writes, []);
+});
+
+test('user sees initialization pending without fabricated timeframe, generation or last-success facts', async (t) => {
+ // Given a server response whose absent selection facts satisfy the real gateway validator.
+ const fixture = remoteFixture(t);
+ validateStrategy29StatusResponse(initialMissingSelection, 200);
+ fixture.gateway.respond(initialMissingSelection);
+ fixture.gateway.respond({ ...events, events: [], next_cursor: 0 });
+
+ // When the real client delivers that first status to the default panel.
+ await fixture.remote.sample();
+
+ // Then the panel keeps pending selection facts explicit and accepts an empty bounded history.
+ assert.equal(fixture.panel().querySelector('[data-role=timeframes]').textContent, '');
+ assert.equal(fixture.panel().querySelector('[data-role=selection]').textContent, 'Waiting for server selection to initialize');
+ assert.equal(fixture.panel().querySelector('[data-role=selection-details]').textContent, 'Waiting for server selection to initialize · Generation pending · 0 markets · 0/0 live units ready');
+ assert.equal(fixture.panel().querySelector('[data-role=selection-refresh]').textContent, 'No successful selection has been observed');
+ assert.equal(fixture.panel().querySelector('[data-role=events]').textContent, 'No signals in retained history');
+ assert.equal(fixture.remote.diagnostics.cursor, 0);
+});
+
+test('user sees only configured timeframe events and long signals use their actual direction color', async (t) => {
+ // Given a structurally valid event page that straddles a server configuration change.
+ const fixture = remoteFixture(t);
+ const longEvent = { ...events.events[0], event_id: 'e'.repeat(64), setup_direction: 'bullish', signal_side: 'long' };
+ const outside = { ...events.events[1], timeframe: '4h' };
+ const page = { ...events, events: [longEvent, outside] };
+ validateStrategy29EventsResponse(page, 200);
+ fixture.gateway.respond(status);
+ fixture.gateway.respond(page);
+
+ // When the real client accepts the protocol page and the panel projects the current configured intervals.
+ await fixture.remote.sample();
+
+ // Then the supported but unconfigured event is hidden and the long signal is rendered in green.
+ const rows = [...fixture.panel().querySelectorAll('[data-role=remote-event]')];
+ assert.deepEqual(rows.map(row => row.dataset.eventId), [longEvent.event_id]);
+ assert.equal(rows[0].children[1].textContent, 'Bullish warning');
+ assert.equal(rows[0].children[1].style.color, 'rgb(14, 203, 129)');
+ assert.equal(fixture.remote.diagnostics.cursor, 42);
+ assert.equal(fixture.panel().querySelector('[data-role=missing-signals]').textContent, 'No retained signals: 5m, 1h');
+});
+
+test('user keeps existing rows when applying the same locale and clamps diagnostics only while the panel is live', (t) => {
+ // Given a real panel with validated status and rows plus a native viewport.
+ const host = createStrategy29ChartHost();
+ host.dom.reconfigure({ url: 'https://www.binance.com/en/futures/BTCUSDT' });
+ const saved = [];
+ const controller = createStrategy29SummaryPanel(host.document, 'BTC/USDT:USDT', {
+ locale: 'en', loadPosition: () => ({ left: 800, top: 600 }), savePosition: value => saved.push(value),
+ });
+ t.after(() => { controller.destroy(); host.close(); });
+ controller.renderStatus(validateStrategy29StatusResponse(status, 200));
+ controller.addEvents(validateStrategy29EventsResponse(events, 200).events, events.observed_at_ms);
+ const panel = host.document.getElementById('jh-strategy29-summary-panel');
+ const originalRows = [...panel.querySelectorAll('[data-role=remote-event]')];
+ const details = panel.querySelector('[data-role=diagnostics]');
+
+ // When the same locale is applied and native diagnostics toggle after a smaller viewport is observed.
+ controller.setLocale('en');
+ Object.defineProperties(host.view, { innerWidth: { configurable: true, value: 300 }, innerHeight: { configurable: true, value: 200 } });
+ details.dispatchEvent(new host.view.Event('toggle'));
+
+ // Then existing event elements are preserved and the live panel stays inside the viewport.
+ assert.deepEqual([...panel.querySelectorAll('[data-role=remote-event]')], originalRows);
+ assert.equal(panel.style.left, '200px');
+ assert.equal(panel.style.top, '176px');
+ assert.deepEqual(saved, []);
+
+ // When a queued native toggle arrives after destruction.
+ controller.destroy();
+ panel.style.left = '777px';
+ details.dispatchEvent(new host.view.Event('toggle'));
+
+ // Then the retired listener performs no clamp or persistence write.
+ assert.equal(panel.isConnected, false);
+ assert.equal(panel.style.left, '777px');
+ assert.deepEqual(saved, []);
+});
diff --git a/test/dom/binance-strategy29-bollinger/tradingview-bearish-alerts.test.js b/test/dom/binance-strategy29-bollinger/tradingview-bearish-alerts.test.js
index 0d61bb6..273ea51 100644
--- a/test/dom/binance-strategy29-bollinger/tradingview-bearish-alerts.test.js
+++ b/test/dom/binance-strategy29-bollinger/tradingview-bearish-alerts.test.js
@@ -3,8 +3,10 @@ import test from 'node:test';
import { readFile } from 'node:fs/promises';
import * as alertApi from '../../../src/binance-strategy29-bollinger/dom/tradingview-bearish-alerts.js';
import { getTradingViewMarkerSaveController } from '../../../src/shared/chart-marker-save-controller.js';
+import { createBollingerMonitor } from '../../../src/binance-strategy29-bollinger/monitor.js';
import { loadFixtureDom } from '../../helpers/dom.js';
+import { captureStrategyError, observeStrategyCondition } from '../../helpers/strategy-migration-boundaries.js';
import {
buildClosedBarsContentKey,
buildClosedBarsContentSnapshot,
@@ -29,8 +31,10 @@ import {
const monitorSource = await readFile(new URL('../../../src/binance-strategy29-bollinger/monitor.js', import.meta.url), 'utf8');
-test('native marker creation and clear save bursts preserve foreign drawings without arming stable audits', async () => {
+test('user observes that native marker creation and clear save bursts preserve foreign drawings without arming stable audits', async () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom();
+ // When fixture.addForeignShape processes the configured inputs
fixture.addForeignShape('user-channel');
const snapshots = [];
const scheduleSave = () => setTimeout(() => fixture.tradingViewApi.saveChart((value) => snapshots.push(value)), 100);
@@ -51,7 +55,9 @@ test('native marker creation and clear save bursts preserve foreign drawings wit
const signals = Array.from({ length: 5 }, (_, i) => ({
id: `signal-${i}`, direction: 'bearish', type: 'warning', time: 60 * (i + 1), markerPrice: 13,
}));
- assert.equal(await layer.render(signals, { isCurrent: () => true }), true);
+ const observedResult = await layer.render(signals, { isCurrent: () => true });
+ // Then user observes that native marker creation and clear save bursts preserve foreign drawings without arming stable audits
+ assert.equal(observedResult, true);
await controller.runAfterIdle(() => {});
assert.equal(layer.saveStats.saveRequests, 10);
assert.equal(layer.saveStats.serializations, 1);
@@ -70,8 +76,10 @@ test('native marker creation and clear save bursts preserve foreign drawings wit
assert.deepEqual(snapshots.at(-1), { drawings: [{ id: 'user-channel' }] });
});
-test('an outer save drain waits for native creation, leaves its late result hidden, and preserves cleanup ownership', async () => {
+test('user observes that an outer save drain waits for native creation, leaves its late result hidden, and preserves cleanup ownership', async () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom({ deferredCreate: true });
+ // When fixture.addForeignShape processes the configured inputs
fixture.addForeignShape('user-channel');
const target = findBearishBollingerChartTarget(fixture.dom.window.document, 'BTRUSDT');
const layer = createBollingerMarkerLayer(target);
@@ -81,6 +89,7 @@ test('an outer save drain waits for native creation, leaves its late result hidd
const controller = getTradingViewMarkerSaveController(fixture.tradingViewApi);
let starts = 0;
const drain = controller.runAfterIdle(() => { starts += 1; });
+ // Then user observes that an outer save drain waits for native creation, leaves its late result hidden, and preserves cleanup ownership
assert.equal(starts, 0);
assert.equal(layer.saveStats.mutations, 1);
fixture.releaseCreate();
@@ -281,8 +290,157 @@ function exportResult(rows) {
};
}
-test('maps TradingView time resolutions to exact bar durations', () => {
- assert.equal(tradingViewResolutionToSeconds('1S'), 1);
+/** Deterministic OHLC history includes real bullish and bearish detector setups. */
+function fullMonitorHistory() {
+ return Array.from({ length: 600 }, (_, index) => {
+ const close = 100 + 15 * Math.sin(index * 2 * Math.PI / 80);
+ const open = index === 0 ? close : 100 + 15 * Math.sin((index - 1) * 2 * Math.PI / 80);
+ return { 0: (index + 1) * 60, 1: open, 2: Math.max(open, close) + 5, 3: Math.min(open, close) - 5, 4: close };
+ });
+}
+
+function fullMonitorFixture(t) {
+ const fixture = createChartDom();
+ Object.defineProperty(fixture.dom.window.document, 'hidden', { configurable: true, value: false });
+ const source = { exported: exportResult(fullMonitorHistory().slice(-240)), requests: 0 };
+ fixture.chart.exportData = async () => { source.requests += 1; return source.exported; };
+ const errors = [], warnings = [];
+ const monitor = createBollingerMonitor({
+ document: fixture.dom.window.document,
+ getCurrentSymbol: () => 'BTRUSDT',
+ isFuturesTradingPage: () => true,
+ isTradingViewDrawingMutationBusy: () => false,
+ err: (...args) => errors.push(args),
+ warn: (...args) => warnings.push(args),
+ });
+ t.after(() => { monitor.stop(); fixture.dom.window.close(); });
+ return {
+ ...fixture, source, monitor, errors, warnings,
+ async sample() {
+ await monitor.tick();
+ await observeStrategyCondition(() => !monitor.diagnostics.taskPending, 'complete real monitor sample');
+ },
+ };
+}
+
+test('user receives the exact native export snapshot used by the full monitor fixture', async (t) => {
+ // Given the fixture export boundary with two independently specified native rows
+ const fixture = fullMonitorFixture(t);
+ const expected = exportResult([{ 0: 60, 1: 100, 2: 105, 3: 95, 4: 101 }]);
+ fixture.source.exported = expected;
+ // When the native export boundary is called directly
+ const received = await fixture.chart.exportData();
+ // Then it returns the original uncorrected schema and rows and counts the request
+ assert.equal(received, expected);
+ assert.deepEqual(received.data, [{ 0: 60, 1: 100, 2: 105, 3: 95, 4: 101 }]);
+ assert.equal(fixture.source.requests, 1);
+});
+
+test('user sees older loaded signals added by the real monitor without a new latest candle or loss of recent markers', async (t) => {
+ // Given a real monitor that has rendered twelve signals from the latest 240 native candles
+ const fixture = fullMonitorFixture(t);
+ fixture.addForeignShape('user-channel');
+ await fixture.sample();
+ const recentIds = [...fixture.shapes.keys()].filter(id => id !== 'user-channel');
+ assert.equal(recentIds.length, 12);
+ assert.equal(fixture.monitor.diagnostics.cachedSignalCount, 12);
+ assert.equal(fixture.source.exported.data.at(-1)[0], 36000);
+
+ // When older native history expands the same latest-candle window to six hundred candles
+ fixture.source.exported = exportResult(fullMonitorHistory());
+ await fixture.sample();
+
+ // Then all thirty-nine real detector signals are retained, including the earliest loaded setup
+ assert.equal(fixture.monitor.diagnostics.cachedSignalCount, 39);
+ assert.equal(fixture.monitor.diagnostics.layerSize, 39);
+ assert.equal(fixture.shapes.size, 40);
+ assert.equal(fixture.source.exported.data.at(-1)[0], 36000);
+ assert.equal(recentIds.every(id => fixture.shapes.has(id)), true);
+ assert.deepEqual(fixture.removed, []);
+ assert.deepEqual([...fixture.shapes.values()].filter(shape => shape.point.time > 0).map(shape => shape.point.time).sort((a, b) => a - b).slice(0, 3), [5760, 5820, 6840]);
+ assert.deepEqual(fixture.errors, []);
+
+ // When another unchanged sample audits the full loaded history
+ const created = fixture.createdOptions.length;
+ await fixture.sample();
+
+ // Then the same markers remain and the monitor does not throttle the native export
+ assert.equal(fixture.createdOptions.length, created);
+ assert.equal(fixture.monitor.diagnostics.cachedSignalCount, 39);
+ assert.equal(fixture.source.requests, 3);
+});
+
+test('user keeps real monitor markers through a snapshot race and resumes the next valid native export', async (t) => {
+ // Given twelve actual detector markers and the original valid native history
+ const fixture = fullMonitorFixture(t);
+ await fixture.sample();
+ const ids = [...fixture.shapes.keys()];
+ const original = fixture.source.exported;
+ const malformed = structuredClone(original);
+ malformed.data[0][2] = malformed.data[0][3] - 1;
+
+ // When the next export contains a transient contradictory OHLC range
+ fixture.source.exported = malformed;
+ await fixture.sample();
+
+ // Then the monitor remains retryable and preserves the verified marker and cache ownership
+ assert.equal(fixture.monitor.diagnostics.failed, false);
+ assert.equal(fixture.monitor.diagnostics.cleanupPending, false);
+ assert.equal(fixture.monitor.diagnostics.lastLocalFailure, null);
+ assert.equal(fixture.monitor.diagnostics.cachedSignalCount, 12);
+ assert.deepEqual([...fixture.shapes.keys()], ids);
+ assert.equal(fixture.warnings.length, 1);
+ assert.equal(isTradingViewBarSnapshotInconsistentError(fixture.warnings[0][1]), true);
+
+ // When the next poll receives a coherent native snapshot
+ fixture.source.exported = original;
+ await fixture.sample();
+
+ // Then the real monitor resumes sampling without replacing unchanged markers
+ assert.equal(fixture.source.requests, 3);
+ assert.deepEqual([...fixture.shapes.keys()], ids);
+ assert.equal(fixture.monitor.diagnostics.failed, false);
+ assert.deepEqual(fixture.errors, []);
+});
+
+test('user sees a fatal real monitor schema failure clear only owned markers on the next cleanup sample', async (t) => {
+ // Given verified detector markers beside a foreign user drawing
+ const fixture = fullMonitorFixture(t);
+ fixture.addForeignShape('user-channel');
+ await fixture.sample();
+
+ // When the native chart returns an invalid export schema
+ fixture.source.exported = { schema: [], data: [] };
+ await fixture.sample();
+
+ // Then the fatal failure records pre-cleanup evidence and schedules owned-layer cleanup
+ assert.equal(fixture.monitor.diagnostics.failed, true);
+ assert.equal(fixture.monitor.diagnostics.cleanupPending, true);
+ assert.equal(fixture.monitor.diagnostics.lastLocalFailure.stage, 'export');
+ assert.equal(fixture.monitor.diagnostics.lastLocalFailure.cachedSignalCount, 12);
+ assert.equal(fixture.monitor.diagnostics.lastLocalFailure.layerSizeBeforeCleanup, 12);
+ assert.match(fixture.monitor.diagnostics.lastLocalFailure.message, /schema mismatch/);
+ assert.equal(fixture.shapes.size, 13);
+
+ // When the next sample executes the deferred fatal cleanup
+ await fixture.sample();
+
+ // Then every owned marker is removed once and the failed context stops exporting
+ assert.deepEqual([...fixture.shapes.keys()], ['user-channel']);
+ assert.equal(fixture.removed.length, 12);
+ assert.equal(fixture.source.requests, 2);
+ assert.equal(fixture.monitor.diagnostics.cleanupPending, false);
+ assert.equal(fixture.monitor.diagnostics.failed, true);
+ assert.equal(fixture.errors.length, 1);
+});
+
+test('user maps TradingView time resolutions to exact bar durations', () => {
+ // Given the chart candles, interval and marker ownership
+ const scenarioInput = '1S';
+ // When tradingViewResolutionToSeconds processes the configured inputs
+ const observedResult = tradingViewResolutionToSeconds(scenarioInput);
+ // Then user maps TradingView time resolutions to exact bar durations
+ assert.equal(observedResult, 1);
assert.equal(tradingViewResolutionToSeconds('1'), 60);
assert.equal(tradingViewResolutionToSeconds('60'), 3600);
assert.equal(tradingViewResolutionToSeconds('4H'), 14400);
@@ -291,15 +449,18 @@ test('maps TradingView time resolutions to exact bar durations', () => {
assert.throws(() => tradingViewResolutionToSeconds('1M'), /unsupported/);
});
-test('native null-owner cleanup preserves alert subscriptions and their readiness transitions', () => {
+test('user observes that native null-owner cleanup preserves alert subscriptions and their readiness transitions', () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom();
let ready = false;
fixture.chart.dataReady = () => ready;
+ // When alertApi.createBollingerIntervalSession processes the configured inputs
const session = alertApi.createBollingerIntervalSession(fixture.chart);
fixture.dataLoaded.subscribe(null, () => {});
fixture.intervalChanged.subscribe(null, () => {});
fixture.dataLoaded.unsubscribeAll(null);
fixture.intervalChanged.unsubscribeAll(null);
+ // Then user observes that native null-owner cleanup preserves alert subscriptions and their readiness transitions
assert.equal(fixture.dataLoaded.size, 1);
assert.equal(fixture.intervalChanged.size, 1);
ready = true;
@@ -317,40 +478,54 @@ test('native null-owner cleanup preserves alert subscriptions and their readines
assert.equal(session.isCurrent(1), false);
});
-test('rejects second bars under a minute target and accepts the replacement minute history', () => {
+test('user rejects second bars under a minute target and accepts the replacement minute history', () => {
+ // Given the chart candles, interval and marker ownership
const row = (time) => ({ 0: time, 1: 10, 2: 12, 3: 9, 4: 11 });
assert.throws(() => parseClosedTradingViewBars(exportResult(
Array.from({ length: 120 }, (_, index) => row(3600 + index)),
), { resolutionSeconds: 60, observedAtSeconds: 4000 }),
isTradingViewBarSnapshotInconsistentError);
+ // When parseClosedTradingViewBars processes the configured inputs
const bars = parseClosedTradingViewBars(exportResult([row(3600), row(3660), row(3780)]), {
resolutionSeconds: 60, observedAtSeconds: 3840,
});
+ // Then user rejects second bars under a minute target and accepts the replacement minute history
assert.deepEqual(bars.map(bar => bar.time), [3600, 3660, 3780]);
});
-test('validates the entire export including off-grid bars that are not closed yet', () => {
- assert.throws(() => parseClosedTradingViewBars(exportResult([
+test('user validates the entire export including off-grid bars that are not closed yet', () => {
+ // Given an off-grid current candle following a correctly aligned minute
+ const exported = exportResult([
{ 0: 3600, 1: 10, 2: 12, 3: 9, 4: 11 },
{ 0: 3661, 1: 10, 2: 12, 3: 9, 4: 11 },
- ]), { resolutionSeconds: 60, observedAtSeconds: 3662 }),
- isTradingViewBarSnapshotInconsistentError);
+ ]);
+ // When the parser validates every exported candle before filtering open bars
+ const failure = captureStrategyError(() => parseClosedTradingViewBars(exported, { resolutionSeconds: 60, observedAtSeconds: 3662 }));
+ // Then even the unclosed off-grid bar is a recoverable snapshot race
+ assert.equal(isTradingViewBarSnapshotInconsistentError(failure), true);
});
-test('accepts multi-day and Monday weekly bars without Unix-epoch phase assumptions', () => {
- for (const [resolutionSeconds, times] of [
+for (const [resolutionSeconds, times] of [
[3 * 86400, [86400, 4 * 86400, 10 * 86400]],
[7 * 86400, [4 * 86400, 11 * 86400, 25 * 86400]],
]) {
- const bars = parseClosedTradingViewBars(exportResult(times.map(time => (
+ test(`user accepts multi-day and Monday weekly bars without Unix-epoch phase assumptions (resolutionSeconds=${JSON.stringify(resolutionSeconds)})`, () => {
+ // Given valid multi-day or Monday weekly candles with historical gaps
+ const exported = exportResult(times.map(time => (
{ 0: time, 1: 10, 2: 12, 3: 9, 4: 11 }
- ))), { resolutionSeconds, observedAtSeconds: 40 * 86400 });
+ )));
+ // When the complete export is parsed for its native resolution
+ const bars = parseClosedTradingViewBars(exported, { resolutionSeconds, observedAtSeconds: 40 * 86400 });
+ // Then every legitimate candle retains its exact timestamp
assert.deepEqual(bars.map(bar => bar.time), times);
- }
-});
-test('interval sessions invalidate A-B-A exports and wait for data completion despite nonempty old data', async () => {
+ });
+}
+
+test('user observes that interval sessions invalidate A-B-A exports and wait for data completion despite nonempty old data', async () => {
+ // Given the chart candles, interval and marker ownership
const { chart, setResolution, dataLoaded, intervalChanged } = createChartDom({ resolution: '1S' });
+ // When alertApi.createBollingerIntervalSession processes the configured inputs
const session = alertApi.createBollingerIntervalSession(chart);
let releaseExport;
chart.exportData = () => new Promise(resolve => { releaseExport = resolve; });
@@ -358,6 +533,7 @@ test('interval sessions invalidate A-B-A exports and wait for data completion de
const pending = alertApi.exportClosedTradingViewBars(target, session, 4000000);
const revision = session.revision;
setResolution('1');
+ // Then user observes that interval sessions invalidate A-B-A exports and wait for data completion despite nonempty old data
assert.equal(chart.dataReady(), true);
assert.equal(session.isCurrent(session.revision), false);
setResolution('1S');
@@ -372,14 +548,17 @@ test('interval sessions invalidate A-B-A exports and wait for data completion de
assert.equal(dataLoaded.size, 0);
});
-test('reconciles moved points, changed signal prices and altered owned colors without touching foreign drawings', async () => {
+test('user observes that reconciles moved points, changed signal prices and altered owned colors without touching foreign drawings', async () => {
+ // Given the chart candles, interval and marker ownership
const { dom, shapes, removed, addForeignShape } = createChartDom();
const layer = createBollingerMarkerLayer(findBearishBollingerChartTarget(dom.window.document, 'BTRUSDT'));
const signal = { id: 'drift', direction: 'bearish', type: 'warning', time: 120, markerPrice: 10 };
+ // When addForeignShape processes the configured inputs
addForeignShape();
await layer.render([signal], { isCurrent: () => true });
shapes.get('shape-1').point.time = 60;
await layer.render([signal], { isCurrent: () => true });
+ // Then user observes that reconciles moved points, changed signal prices and altered owned colors without touching foreign drawings
assert.deepEqual(shapes.get('shape-2').point, { time: 120, price: 10 });
shapes.get('shape-2').point.price = 12;
await layer.render([signal], { isCurrent: () => true });
@@ -396,16 +575,19 @@ test('reconciles moved points, changed signal prices and altered owned colors wi
assert.equal(shapes.has('foreign-shape'), true);
});
-test('native interval visibility hides second markers on minutes even while cleanup is busy', async () => {
+test('user observes that native interval visibility hides second markers on minutes even while cleanup is busy', async () => {
+ // Given the chart candles, interval and marker ownership
const { dom, shapes, removed, setResolution } = createChartDom({ resolution: '1S' });
let busy = false;
const layer = createBollingerMarkerLayer(findBearishBollingerChartTarget(dom.window.document, 'BTRUSDT'), {
canMutate: () => !busy,
});
+ // When layer.render processes the configured inputs
await layer.render([{ id: 'second', direction: 'bearish', type: 'warning', time: 3601, markerPrice: 10 }], {
isCurrent: () => true,
});
const visibility = shapes.get('shape-1').properties.overrides.intervalsVisibilities;
+ // Then user observes that native interval visibility hides second markers on minutes even while cleanup is busy
assert.equal(visibility.seconds, true);
assert.equal(visibility.secondsFrom, 1);
assert.equal(visibility.secondsTo, 1);
@@ -419,17 +601,20 @@ test('native interval visibility hides second markers on minutes even while clea
assert.equal(shapes.size, 0);
});
-test('retains late async marker ownership until a busy chart permits cleanup', async () => {
+test('user retains late async marker ownership until a busy chart permits cleanup', async () => {
+ // Given the chart candles, interval and marker ownership
const { dom, shapes, removed, releaseCreate, setResolution, createdOptions, propertyUpdates } = createChartDom({ resolution: '1S', deferredCreate: true });
let busy = false;
let current = true;
const layer = createBollingerMarkerLayer(findBearishBollingerChartTarget(dom.window.document, 'BTRUSDT'), {
canMutate: () => !busy,
});
+ // When layer.render processes the configured inputs
const pending = layer.render([{ id: 'late', direction: 'bearish', type: 'warning', time: 3601, markerPrice: 10 }], {
isCurrent: () => current,
});
await Promise.resolve();
+ // Then user retains late async marker ownership until a busy chart permits cleanup
assert.equal(layer.clear(), false);
current = false;
busy = true;
@@ -448,14 +633,17 @@ test('retains late async marker ownership until a busy chart permits cleanup', a
assert.deepEqual(removed, ['shape-1']);
});
-test('publishes a current hidden creation only after restoring its exact interval mask', async () => {
+test('user publishes a current hidden creation only after restoring its exact interval mask', async () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom({ resolution: '1S', deferredCreate: true });
const layer = createBollingerMarkerLayer(findBearishBollingerChartTarget(fixture.dom.window.document, 'BTRUSDT'));
+ // When layer.render processes the configured inputs
const pending = layer.render([{ id: 'publish', direction: 'bullish', type: 'confirmed', time: 3601, markerPrice: 10 }], {
isCurrent: () => true,
});
fixture.setResolution('1');
fixture.releaseCreate();
+ // Then user publishes a current hidden creation only after restoring its exact interval mask
assert.equal(await pending, true);
assert.equal(fixture.createdOptions[0].overrides.visible, false);
assert.equal(fixture.propertyUpdates.length, 1);
@@ -467,15 +655,18 @@ test('publishes a current hidden creation only after restoring its exact interva
assert.equal(properties.arrowColor, '#0ECB81');
});
-test('production monitor retires old interval before readiness and resumes with minute data', async () => {
+test('user observes that production monitor retires old interval before readiness and resumes with minute data', async () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom({ resolution: '1S' });
const harness = createMonitorHarness(fixture);
fixture.chart.exportData = async () => exportResult([
{ 0: 3601, 1: 10, 2: 12, 3: 9, 4: 11 },
{ 0: 3602, 1: 10, 2: 12, 3: 9, 4: 11 },
]);
+ // When harness.tick processes the configured inputs
await harness.tick();
const session = harness.monitor.session.session;
+ // Then user observes that production monitor retires old interval before readiness and resumes with minute data
assert.equal(fixture.shapes.size, 1);
harness.setBusy(true);
fixture.setResolution('1');
@@ -504,17 +695,20 @@ test('production monitor retires old interval before readiness and resumes with
harness.monitor.stop();
});
-test('production monitor stop disposes subscriptions and invalidates busy pending export', async () => {
+test('user observes that production monitor stop disposes subscriptions and invalidates busy pending export', async () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom({ resolution: '1S' });
const harness = createMonitorHarness(fixture);
let releaseExport;
fixture.chart.exportData = () => new Promise(resolve => { releaseExport = resolve; });
+ // When harness.monitor.tick processes the configured inputs
await harness.monitor.tick();
const oldTask = harness.monitor.task;
const oldSession = harness.monitor.session.session;
harness.setBusy(true);
harness.setHidden(true);
harness.monitor.stop();
+ // Then user observes that production monitor stop disposes subscriptions and invalidates busy pending export
assert.equal(harness.monitor.context, null);
assert.equal(harness.monitor.session, null);
assert.equal(oldSession.isCurrent(oldSession.revision), false);
@@ -535,16 +729,19 @@ test('production monitor stop disposes subscriptions and invalidates busy pendin
assert.deepEqual(harness.errors, []);
});
-test('production monitor retains a retired layer until late creation and busy cleanup finish', async () => {
+test('user observes that production monitor retains a retired layer until late creation and busy cleanup finish', async () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom({ resolution: '1S', deferredCreate: true });
const harness = createMonitorHarness(fixture);
fixture.chart.exportData = async () => exportResult([{ 0: 3601, 1: 10, 2: 12, 3: 9, 4: 11 }]);
+ // When harness.monitor.tick processes the configured inputs
await harness.monitor.tick();
await Promise.resolve();
const oldTask = harness.monitor.task;
harness.setBusy(true);
fixture.setResolution('1');
await harness.monitor.tick();
+ // Then user observes that production monitor retains a retired layer until late creation and busy cleanup finish
assert.equal(harness.monitor.context, null);
fixture.releaseCreate();
await oldTask;
@@ -559,15 +756,18 @@ test('production monitor retains a retired layer until late creation and busy cl
harness.monitor.stop();
});
-test('production monitor detects a round-trip interval switch between polls', async () => {
+test('user observes that production monitor detects a round-trip interval switch between polls', async () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom({ resolution: '1S' });
const harness = createMonitorHarness(fixture);
fixture.chart.exportData = async () => exportResult([{ 0: 3601, 1: 10, 2: 12, 3: 9, 4: 11 }]);
+ // When harness.tick processes the configured inputs
await harness.tick();
const originalContext = harness.monitor.context;
fixture.setResolution('1');
fixture.setResolution('1S');
await harness.tick();
+ // Then user observes that production monitor detects a round-trip interval switch between polls
assert.equal(harness.monitor.context, null);
assert.equal(fixture.shapes.size, 0);
assert.equal(harness.detectorCalls, 1);
@@ -580,16 +780,19 @@ test('production monitor detects a round-trip interval switch between polls', as
harness.monitor.stop();
});
-test('production monitor disposes old chart subscriptions even when removal is busy', async () => {
+test('user observes that production monitor disposes old chart subscriptions even when removal is busy', async () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom({ resolution: '1S' });
const harness = createMonitorHarness(fixture);
fixture.chart.exportData = async () => exportResult([{ 0: 3601, 1: 10, 2: 12, 3: 9, 4: 11 }]);
+ // When harness.tick processes the configured inputs
await harness.tick();
const replacement = createChartDom({ resolution: '1S' });
replacement.chart.exportData = fixture.chart.exportData;
harness.setBusy(true);
fixture.setActiveChart(replacement.chart);
await harness.tick();
+ // Then user observes that production monitor disposes old chart subscriptions even when removal is busy
assert.equal(fixture.intervalChanged.size, 0);
assert.equal(fixture.dataLoaded.size, 0);
assert.equal(harness.monitor.context, null);
@@ -604,33 +807,46 @@ test('production monitor disposes old chart subscriptions even when removal is b
assert.equal(replacement.intervalChanged.size, 0);
});
-test('uses native visibility buckets for Binance seconds, minutes, hours, days and weeks', () => {
- for (const [resolution, unit, count] of [
+for (const [resolution, unit, count] of [
['1S', 'seconds', 1], ['90S', 'minutes', 1], ['15', 'minutes', 15], ['60', 'hours', 1],
['4H', 'hours', 4], ['1D', 'days', 1], ['1W', 'weeks', 1],
]) {
- const visibility = alertApi.bollingerIntervalVisibility(resolution);
+ test(`user uses native visibility buckets for Binance seconds, minutes, hours, days and weeks (resolution=${JSON.stringify(resolution)})`, () => {
+ // Given a Binance chart resolution with its native visibility bucket
+ const sourceResolution = resolution;
+ // When the marker visibility mask is constructed
+ const visibility = alertApi.bollingerIntervalVisibility(sourceResolution);
+ // Then only the exact expected bucket is enabled
assert.equal(visibility[unit], true);
assert.equal(visibility[`${unit}From`], count);
assert.equal(visibility[`${unit}To`], count);
assert.deepEqual(Object.entries(visibility).filter(([, value]) => value === true).map(([key]) => key), [unit]);
- }
-});
-test('rejects weekly bars off Monday while preserving legitimate multiweek gaps', () => {
+ });
+}
+
+test('user rejects weekly bars off Monday while preserving legitimate multiweek gaps', () => {
+ // Given weekly candles on the wrong weekday and legitimate Monday candles
const row = time => ({ 0: time, 1: 10, 2: 12, 3: 9, 4: 11 });
- assert.throws(() => parseClosedTradingViewBars(exportResult([row(0), row(604800)]), {
+ // When the parser checks the off-Monday export
+ const failure = captureStrategyError(() => parseClosedTradingViewBars(exportResult([row(0), row(604800)]), {
resolution: '1W', resolutionSeconds: 604800, observedAtSeconds: 2000000,
- }), isTradingViewBarSnapshotInconsistentError);
+ }));
+ // Then the off-Monday candles fail and valid multiweek gaps remain intact
+ assert.equal(isTradingViewBarSnapshotInconsistentError(failure), true);
assert.deepEqual(parseClosedTradingViewBars(exportResult([row(345600), row(1555200)]), {
resolution: '1W', resolutionSeconds: 604800, observedAtSeconds: 3000000,
}).map(bar => bar.time), [345600, 1555200]);
});
-test('waits for the model before reading a chart target and invalidates a torn-down model', () => {
+test('user waits for the model before reading a chart target and invalidates a torn-down model', () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom();
+ // When fixture.setModelReady processes the configured inputs
fixture.setModelReady(false);
- assert.equal(findBearishBollingerChartTarget(fixture.dom.window.document, 'BTRUSDT'), null);
+ const observedResult = findBearishBollingerChartTarget(fixture.dom.window.document, 'BTRUSDT');
+ // Then user waits for the model before reading a chart target and invalidates a torn-down model
+ assert.equal(observedResult, null);
fixture.setModelReady(true);
const target = findBearishBollingerChartTarget(fixture.dom.window.document, 'BTRUSDT');
assert.equal(target.resolution, '1');
@@ -638,12 +854,15 @@ test('waits for the model before reading a chart target and invalidates a torn-d
assert.equal(isBearishBollingerChartTargetCurrent(fixture.dom.window.document, target), false);
});
-test('production monitor waits through first-refresh model creation without errors and then renders', async () => {
+test('user observes that production monitor waits through first-refresh model creation without errors and then renders', async () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom();
const harness = createMonitorHarness(fixture);
fixture.chart.exportData = async () => exportResult([{ 0: 60, 1: 10, 2: 12, 3: 9, 4: 11 }]);
+ // When fixture.setModelReady processes the configured inputs
fixture.setModelReady(false);
await harness.tick();
+ // Then user observes that production monitor waits through first-refresh model creation without errors and then renders
assert.deepEqual(harness.errors, []);
assert.equal(harness.monitor.context, null);
assert.equal(fixture.intervalChanged.size, 0);
@@ -656,16 +875,19 @@ test('production monitor waits through first-refresh model creation without erro
harness.monitor.stop();
});
-test('on-demand diagnostics distinguish active, awaiting-data and torn-down states without drawing calls', async () => {
+test('user observes that on-demand diagnostics distinguish active, awaiting-data and torn-down states without drawing calls', async () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom();
const harness = createMonitorHarness(fixture);
fixture.chart.exportData = async () => exportResult([{ 0: 60, 1: 10, 2: 12, 3: 9, 4: 11 }]);
assert.equal(harness.monitor.diagnostics.contextPresent, false);
assert.equal(harness.monitor.diagnostics.nativeModelReady, null);
+ // When harness.tick processes the configured inputs
await harness.tick();
const originalGetAllShapes = fixture.chart.getAllShapes;
fixture.chart.getAllShapes = () => { throw new Error('Diagnostics must not audit drawings'); };
fixture.chart.exportData = () => { throw new Error('Diagnostics must not export data'); };
+ // Then user observes that on-demand diagnostics distinguish active, awaiting-data and torn-down states without drawing calls
assert.deepEqual(harness.monitor.diagnostics, {
taskPending: false, contextPresent: true, failed: false, lastLocalFailure: null,
cleanupPending: false, cachedSignalCount: 1, layerSize: 1, retiredCount: 0,
@@ -687,12 +909,16 @@ test('on-demand diagnostics distinguish active, awaiting-data and torn-down stat
harness.monitor.stop();
});
-test('initial one-second alignment failure retains requested and native times after cleanup', async () => {
+test('user observes that initial one-second alignment failure retains requested and native times after cleanup', async () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom({ resolution: '1S', shiftSeconds: -60 });
const harness = createMonitorHarness(fixture);
fixture.chart.exportData = async () => exportResult([{ 0: 120, 1: 10, 2: 12, 3: 9, 4: 11 }]);
const message = 'TradingView Bollinger alert time alignment failed: expected 120, received 60';
- await assert.rejects(harness.tick(), { message });
+ // When harness.tick processes the configured inputs
+ const observedResult = harness.tick();
+ // Then user observes that initial one-second alignment failure retains requested and native times after cleanup
+ await assert.rejects(observedResult, { message });
await harness.tick();
assert.equal(harness.monitor.diagnostics.failed, true);
assert.equal(harness.monitor.diagnostics.layerSize, 0);
@@ -709,7 +935,8 @@ test('initial one-second alignment failure retains requested and native times af
});
for (const stage of ['export', 'render']) {
- test(`retains the last local ${stage} failure after clearing the layer and stopping`, async () => {
+ test(`user retains the last local ${stage} failure after clearing the layer and stopping`, async () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom();
const harness = createMonitorHarness(fixture, {
detectBollingerSignals: bars => bars.map(bar => ({
@@ -720,7 +947,9 @@ for (const stage of ['export', 'render']) {
fixture.chart.exportData = async () => exportResult(Array.from({ length: 6 }, (_, index) => ({
0: (index + 1) * 60, 1: 10, 2: 12, 3: 9, 4: 11,
})));
+ // When harness.tick processes the configured inputs
await harness.tick();
+ // Then user retains the last local the selected case failure after clearing the layer and stopping
assert.equal(harness.monitor.diagnostics.cachedSignalCount, 6);
assert.equal(harness.monitor.diagnostics.layerSize, 6);
if (stage === 'export') fixture.chart.exportData = async () => { throw new Error('synthetic export failure'); };
@@ -745,11 +974,15 @@ for (const stage of ['export', 'render']) {
}
for (const value of ['x'.repeat(600), null, { code: 7 }]) {
- test(`records ${value === null ? 'null' : typeof value} host rejection without a diagnostic rejection`, async () => {
+ test(`user records ${value === null ? 'null' : typeof value} host rejection without a diagnostic rejection`, async () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom();
const harness = createMonitorHarness(fixture);
fixture.chart.exportData = async () => { throw value; };
- await assert.rejects(harness.tick(), reason => reason === value);
+ // When harness.tick processes the configured inputs
+ const observedResult = harness.tick();
+ // Then user records the selected case host rejection without a diagnostic rejection
+ await assert.rejects(observedResult, reason => reason === value);
await harness.tick();
assert.equal(harness.monitor.diagnostics.failed, true);
assert.equal(harness.monitor.diagnostics.cleanupPending, false);
@@ -768,15 +1001,19 @@ for (const value of ['x'.repeat(600), null, { code: 7 }]) {
});
}
-test('keeps a recoverable snapshot race out of fatal diagnostics and resumes exports', async () => {
+test('user keeps a recoverable snapshot race out of fatal diagnostics and resumes exports', async () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom();
const harness = createMonitorHarness(fixture);
const stable = async () => exportResult([{ 0: 60, 1: 10, 2: 12, 3: 9, 4: 11 }]);
fixture.chart.exportData = stable;
+ // When harness.tick processes the configured inputs
await harness.tick();
const failure = new TradingViewBarSnapshotInconsistentError('synthetic snapshot race');
fixture.chart.exportData = async () => { throw failure; };
- await assert.rejects(harness.tick(), reason => reason === failure);
+ const observedResult = harness.tick();
+ // Then user keeps a recoverable snapshot race out of fatal diagnostics and resumes exports
+ await assert.rejects(observedResult, reason => reason === failure);
assert.equal(harness.monitor.diagnostics.failed, false);
assert.equal(harness.monitor.diagnostics.cleanupPending, false);
assert.equal(harness.monitor.diagnostics.lastLocalFailure, null);
@@ -791,9 +1028,11 @@ test('keeps a recoverable snapshot race out of fatal diagnostics and resumes exp
});
for (const revoked of [true, false]) {
- test(`stops an unclassifiable host Proxy rejection (revoked=${revoked})`, async () => {
+ test(`user stops an unclassifiable host Proxy rejection (revoked=${revoked})`, async () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom();
const harness = createMonitorHarness(fixture);
+ // When Proxy.revocable processes the configured inputs
const host = Proxy.revocable({}, { getPrototypeOf() {
throw new Error('synthetic host prototype failure');
} });
@@ -808,6 +1047,7 @@ for (const revoked of [true, false]) {
await harness.tick();
await harness.tick();
const recorded = harness.monitor.diagnostics.lastLocalFailure;
+ // Then user stops an unclassifiable host Proxy rejection (revoked=the selected case)
assert.equal(recorded.classificationFailed, true);
assert.equal(recorded.thrownType, 'object');
assert.equal(recorded.name, null);
@@ -824,7 +1064,8 @@ for (const revoked of [true, false]) {
}
for (const throwing of [true, false]) {
- test(`reads host rejection accessors once and records unreadable fields (throwing=${throwing})`, async () => {
+ test(`user reads host rejection accessors once and records unreadable fields (throwing=${throwing})`, async () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom();
const harness = createMonitorHarness(fixture);
const reads = { name: 0, message: 0 };
@@ -837,7 +1078,10 @@ for (const throwing of [true, false]) {
} });
}
fixture.chart.exportData = async () => { throw rejection; };
- await assert.rejects(harness.tick(), reason => reason === rejection);
+ // When harness.tick processes the configured inputs
+ const observedResult = harness.tick();
+ // Then user reads host rejection accessors once and records unreadable fields (throwing=the selected case)
+ await assert.rejects(observedResult, reason => reason === rejection);
await harness.tick();
assert.deepEqual(reads, { name: 1, message: 1 });
const recorded = harness.monitor.diagnostics.lastLocalFailure;
@@ -854,7 +1098,8 @@ for (const throwing of [true, false]) {
}
for (const stage of ['detect', 'reconcile']) {
- test(`identifies ${stage} failures before rendering`, async () => {
+ test(`user identifies ${stage} failures before rendering`, async () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom();
const failure = new Error('synthetic detector failure');
failure.name = 'N'.repeat(80);
@@ -866,7 +1111,10 @@ for (const stage of ['detect', 'reconcile']) {
});
fixture.chart.exportData = async () => exportResult([{ 0: 60, 1: 10, 2: 12, 3: 9, 4: 11 }]);
const message = stage === 'detect' ? failure.message : 'Bollinger signal cache is invalid';
- await assert.rejects(harness.tick(), { message });
+ // When harness.tick processes the configured inputs
+ const observedResult = harness.tick();
+ // Then user identifies the selected case failures before rendering
+ await assert.rejects(observedResult, { message });
await harness.tick();
assert.equal(harness.monitor.diagnostics.lastLocalFailure.stage, stage);
assert.equal(harness.monitor.diagnostics.lastLocalFailure.name, stage === 'detect' ? 'N'.repeat(64) : 'Error');
@@ -878,14 +1126,17 @@ for (const stage of ['detect', 'reconcile']) {
});
}
-test('requires the current symbol and complete bearish-alert chart API', () => {
+test('user requires the current symbol and complete bearish-alert chart API', () => {
+ // Given the chart candles, interval and marker ownership
const {
dom,
setActiveChart,
setResolution,
setSymbol,
} = createChartDom({ resolution: '60' });
+ // When findBearishBollingerChartTarget processes the configured inputs
const target = findBearishBollingerChartTarget(dom.window.document, 'BTRUSDT');
+ // Then user requires the current symbol and complete bearish-alert chart API
assert.equal(target.routeSymbol, 'BTRUSDT');
assert.equal(target.resolution, '60');
assert.equal(target.resolutionSeconds, 3600);
@@ -906,18 +1157,22 @@ test('requires the current symbol and complete bearish-alert chart API', () => {
assert.equal(isBearishBollingerChartTargetCurrent(dom.window.document, target), false);
});
-test('exports only bars whose resolution-derived end time has passed', () => {
+test('user exports only bars whose resolution-derived end time has passed', () => {
+ // Given the chart candles, interval and marker ownership
const exported = exportResult([
{ 0: 60, 1: 10, 2: 12, 3: 9, 4: 11 },
{ 0: 120, 1: 11, 2: 13, 3: 10, 4: 12 },
{ 0: 180, 1: 12, 2: 20, 3: 5, 4: 19 },
]);
- assert.deepEqual(
- parseClosedTradingViewBars(exported, {
+ // When parseClosedTradingViewBars processes the configured inputs
+ const observedResult = parseClosedTradingViewBars(exported, {
resolutionSeconds: 60,
observedAtSeconds: 180,
- }),
+ });
+ // Then user exports only bars whose resolution-derived end time has passed
+ assert.deepEqual(
+ observedResult,
[
{ time: 60, open: 10, high: 12, low: 9, close: 11 },
{ time: 120, open: 11, high: 13, low: 10, close: 12 },
@@ -925,20 +1180,23 @@ test('exports only bars whose resolution-derived end time has passed', () => {
);
});
-test('classifies a non-monotonic export as a recoverable TradingView snapshot race', () => {
- assert.throws(
- () => parseClosedTradingViewBars(exportResult([
+test('user classifies a non-monotonic export as a recoverable TradingView snapshot race', () => {
+ // Given native export rows whose timestamps move backwards
+ const exported = exportResult([
{ 0: 120, 1: 11, 2: 13, 3: 10, 4: 12 },
{ 0: 60, 1: 10, 2: 12, 3: 9, 4: 11 },
- ]), {
+ ]);
+ // When the parser checks the native snapshot ordering
+ const failure = captureStrategyError(() => parseClosedTradingViewBars(exported, {
resolutionSeconds: 60,
observedAtSeconds: 180,
- }),
- (error) => isTradingViewBarSnapshotInconsistentError(error),
- );
+ }));
+ // Then the failure is classified as a retryable snapshot race
+ assert.equal(isTradingViewBarSnapshotInconsistentError(failure), true);
});
-test('keeps every closed bar already loaded by TradingView', () => {
+test('user keeps every closed bar already loaded by TradingView', () => {
+ // Given the chart candles, interval and marker ownership
const rows = Array.from({ length: 505 }, (_, index) => ({
0: (index + 1) * 60,
1: 10,
@@ -946,17 +1204,20 @@ test('keeps every closed bar already loaded by TradingView', () => {
3: 9,
4: 11,
}));
+ // When parseClosedTradingViewBars processes the configured inputs
const bars = parseClosedTradingViewBars(exportResult(rows), {
resolutionSeconds: 60,
observedAtSeconds: 506 * 60,
});
+ // Then user keeps every closed bar already loaded by TradingView
assert.equal(bars.length, 505);
assert.equal(bars[0].time, 60);
assert.equal(bars.at(-1).time, 505 * 60);
});
-test('changes the closed-bar window key when older history loads without a new latest bar', () => {
+test('user changes the closed-bar window key when older history loads without a new latest bar', () => {
+ // Given the same latest candle with an expanded older history window
const recent = [
{ time: 120, open: 11, high: 13, low: 10, close: 12 },
{ time: 180, open: 12, high: 14, low: 11, close: 13 },
@@ -966,7 +1227,10 @@ test('changes the closed-bar window key when older history loads without a new l
...recent,
];
- assert.notEqual(buildClosedBarsWindowKey(recent), buildClosedBarsWindowKey(expanded));
+ // When the window identity is calculated for the recent bars
+ const observedResult = buildClosedBarsWindowKey(recent);
+ // Then adding older history changes identity even without a newer latest bar
+ assert.notEqual(observedResult, buildClosedBarsWindowKey(expanded));
assert.equal(buildClosedBarsWindowKey(recent), '2:120:180');
assert.equal(buildClosedBarsWindowKey(expanded), '3:60:180');
assert.equal(buildClosedBarsWindowKey(recent), buildClosedBarsWindowKey([...recent]));
@@ -979,7 +1243,8 @@ test('changes the closed-bar window key when older history loads without a new l
);
});
-test('changes the content key when OHLC changes inside the same closed-bar window', () => {
+test('user changes the content key when OHLC changes inside the same closed-bar window', () => {
+ // Given equal timestamp windows with a corrected candle high
const bars = [
{ time: 120, open: 11, high: 13, low: 10, close: 12 },
{ time: 180, open: 12, high: 14, low: 11, close: 13 },
@@ -989,24 +1254,31 @@ test('changes the content key when OHLC changes inside the same closed-bar windo
{ ...bars[1], high: 15 },
];
- assert.equal(buildClosedBarsWindowKey(bars), buildClosedBarsWindowKey(corrected));
+ // When the timestamp identity and candle content are compared
+ const observedResult = buildClosedBarsWindowKey(bars);
+ // Then the window identity is stable while content identity detects the correction
+ assert.equal(observedResult, buildClosedBarsWindowKey(corrected));
assert.notEqual(buildClosedBarsContentKey(bars), buildClosedBarsContentKey(corrected));
const snapshot = buildClosedBarsContentSnapshot(bars);
assert.equal(matchesClosedBarsContentSnapshot(bars, snapshot), true);
assert.equal(matchesClosedBarsContentSnapshot(corrected, snapshot), false);
});
-test('renders warning, bearish confirmation, and bullish reversal markers', async () => {
+test('user renders warning, bearish confirmation, and bullish reversal markers', async () => {
+ // Given the chart candles, interval and marker ownership
const { dom, shapes, removed } = createChartDom();
+ // When findBearishBollingerChartTarget processes the configured inputs
const target = findBearishBollingerChartTarget(dom.window.document, 'BTRUSDT');
const layer = createBearishBollingerMarkerLayer(target);
const isCurrent = () => true;
- assert.equal(await layer.render([
+ const observedResult = await layer.render([
{ id: 'setup:warning', type: 'warning', time: 120, markerPrice: 10 },
{ id: 'setup:confirmed', type: 'confirmed', time: 180, markerPrice: 9 },
{ id: 'setup:reversal', type: 'reversal', time: 240, markerPrice: 8 },
- ], { isCurrent }), true);
+ ], { isCurrent });
+ // Then user renders warning, bearish confirmation, and bullish reversal markers
+ assert.equal(observedResult, true);
assert.equal(shapes.size, 3);
const records = [...shapes.values()];
assert.equal(records[0].properties.shape, 'icon');
@@ -1025,8 +1297,10 @@ test('renders warning, bearish confirmation, and bullish reversal markers', asyn
assert.deepEqual(removed, ['shape-1', 'shape-2']);
});
-test('renders mirrored bullish marker shapes and colors in the shared layer', async () => {
+test('user renders mirrored bullish marker shapes and colors in the shared layer', async () => {
+ // Given the chart candles, interval and marker ownership
const { dom, shapes } = createChartDom();
+ // When findBearishBollingerChartTarget processes the configured inputs
const target = findBearishBollingerChartTarget(dom.window.document, 'BTRUSDT');
const layer = createBearishBollingerMarkerLayer(target);
@@ -1055,6 +1329,7 @@ test('renders mirrored bullish marker shapes and colors in the shared layer', as
], { isCurrent: () => true });
const records = [...shapes.values()];
+ // Then user renders mirrored bullish marker shapes and colors in the shared layer
assert.equal(records[0].properties.shape, 'icon');
assert.equal(records[0].properties.overrides.color, '#0ECB81');
assert.equal(records[1].properties.shape, 'arrow_up');
@@ -1063,8 +1338,10 @@ test('renders mirrored bullish marker shapes and colors in the shared layer', as
assert.equal(records[2].properties.overrides.arrowColor, '#F6465D');
});
-test('keeps opposite-direction signals on the same candle as distinct markers', async () => {
+test('user keeps opposite-direction signals on the same candle as distinct markers', async () => {
+ // Given the chart candles, interval and marker ownership
const { dom, shapes } = createChartDom();
+ // When findBearishBollingerChartTarget processes the configured inputs
const target = findBearishBollingerChartTarget(dom.window.document, 'BTRUSDT');
const layer = createBollingerMarkerLayer(target);
@@ -1085,6 +1362,7 @@ test('keeps opposite-direction signals on the same candle as distinct markers',
},
], { isCurrent: () => true });
+ // Then user keeps opposite-direction signals on the same candle as distinct markers
assert.equal(shapes.size, 2);
const records = [...shapes.values()];
assert.deepEqual(
@@ -1093,25 +1371,31 @@ test('keeps opposite-direction signals on the same candle as distinct markers',
);
});
-test('requires explicit direction when using the shared marker layer', async () => {
+test('user requires explicit direction when using the shared marker layer', async () => {
+ // Given the chart candles, interval and marker ownership
const { dom, shapes } = createChartDom();
+ // When findBearishBollingerChartTarget processes the configured inputs
const target = findBearishBollingerChartTarget(dom.window.document, 'BTRUSDT');
const layer = createBollingerMarkerLayer(target);
- await assert.rejects(
- layer.render([{
+ const observedResult = layer.render([{
id: 'missing-direction',
type: 'warning',
time: 120,
markerPrice: 10,
- }], { isCurrent: () => true }),
+ }], { isCurrent: () => true });
+ // Then user requires explicit direction when using the shared marker layer
+ await assert.rejects(
+ observedResult,
/direction is invalid/,
);
assert.equal(shapes.size, 0);
});
-test('keeps existing markers through a recoverable snapshot error and retries next tick', async () => {
+test('user keeps existing markers through a recoverable snapshot error and retries next tick', async () => {
+ // Given the chart candles, interval and marker ownership
const { dom, shapes } = createChartDom();
+ // When findBearishBollingerChartTarget processes the configured inputs
const target = findBearishBollingerChartTarget(dom.window.document, 'BTRUSDT');
const layer = createBollingerMarkerLayer(target);
const signal = {
@@ -1126,6 +1410,7 @@ test('keeps existing markers through a recoverable snapshot error and retries ne
{ time: 120, open: 11, high: 13, low: 10, close: 12 },
];
await layer.render([signal], { isCurrent: () => true });
+ // Then user keeps existing markers through a recoverable snapshot error and retries next tick
assert.equal(shapes.size, 1);
let detectorCalls = 0;
@@ -1164,8 +1449,10 @@ test('keeps existing markers through a recoverable snapshot error and retries ne
assert.equal(shapes.size, 2);
});
-test('keeps the task context retryable across malformed-to-valid snapshots', async () => {
+test('user keeps the task context retryable across malformed-to-valid snapshots', async () => {
+ // Given the chart candles, interval and marker ownership
const { dom, shapes } = createChartDom();
+ // When findBearishBollingerChartTarget processes the configured inputs
const target = findBearishBollingerChartTarget(dom.window.document, 'BTRUSDT');
const layer = createBollingerMarkerLayer(target);
const signal = {
@@ -1198,6 +1485,7 @@ test('keeps the task context retryable across malformed-to-valid snapshots', asy
let detectorCalls = 0;
let snapshotError = null;
+ // Then user keeps the task context retryable across malformed-to-valid snapshots
await assert.rejects(
reconcileBearishBollingerAlertWindow({
bars: malformedBars,
@@ -1244,13 +1532,15 @@ test('keeps the task context retryable across malformed-to-valid snapshots', asy
assert.equal(layer.size, 2);
});
-test('recreates a marker that TradingView evicted outside the alert layer', async () => {
+test('user recreates a marker that TradingView evicted outside the alert layer', async () => {
+ // Given the chart candles, interval and marker ownership
const {
dom,
shapes,
removed,
evictShape,
} = createChartDom();
+ // When findBearishBollingerChartTarget processes the configured inputs
const target = findBearishBollingerChartTarget(dom.window.document, 'BTRUSDT');
const layer = createBearishBollingerMarkerLayer(target);
const signals = [{
@@ -1260,7 +1550,9 @@ test('recreates a marker that TradingView evicted outside the alert layer', asyn
markerPrice: 10,
}];
- assert.equal(await layer.render(signals, { isCurrent: () => true }), true);
+ const observedResult = await layer.render(signals, { isCurrent: () => true });
+ // Then user recreates a marker that TradingView evicted outside the alert layer
+ assert.equal(observedResult, true);
assert.equal(shapes.has('shape-1'), true);
evictShape('shape-1');
@@ -1271,13 +1563,15 @@ test('recreates a marker that TradingView evicted outside the alert layer', asyn
assert.deepEqual(removed, []);
});
-test('same closed-bar window reuses detection and still restores an evicted marker', async () => {
+test('user observes that same closed-bar window reuses detection and still restores an evicted marker', async () => {
+ // Given the chart candles, interval and marker ownership
const {
dom,
shapes,
removed,
evictShape,
} = createChartDom();
+ // When findBearishBollingerChartTarget processes the configured inputs
const target = findBearishBollingerChartTarget(dom.window.document, 'BTRUSDT');
const layer = createBearishBollingerMarkerLayer(target);
const bars = [
@@ -1319,6 +1613,7 @@ test('same closed-bar window reuses detection and still restores an evicted mark
}
await runMonitorTick();
+ // Then user observes that same closed-bar window reuses detection and still restores an evicted marker
assert.equal(shapes.has('shape-1'), true);
evictShape('shape-1');
@@ -1331,7 +1626,8 @@ test('same closed-bar window reuses detection and still restores an evicted mark
assert.deepEqual(removed, []);
});
-test('reconciliation, signal removal, and clear preserve foreign drawings', async () => {
+test('user observes that reconciliation, signal removal, and clear preserve foreign drawings', async () => {
+ // Given the chart candles, interval and marker ownership
const {
dom,
shapes,
@@ -1339,6 +1635,7 @@ test('reconciliation, signal removal, and clear preserve foreign drawings', asyn
evictShape,
addForeignShape,
} = createChartDom();
+ // When findBearishBollingerChartTarget processes the configured inputs
const target = findBearishBollingerChartTarget(dom.window.document, 'BTRUSDT');
const layer = createBearishBollingerMarkerLayer(target);
const foreignId = addForeignShape();
@@ -1353,6 +1650,7 @@ test('reconciliation, signal removal, and clear preserve foreign drawings', asyn
evictShape('shape-1');
await layer.render([signal], { isCurrent: () => true });
+ // Then user observes that reconciliation, signal removal, and clear preserve foreign drawings
assert.equal(shapes.has(foreignId), true);
assert.deepEqual(removed, []);
@@ -1368,13 +1666,15 @@ test('reconciliation, signal removal, and clear preserve foreign drawings', asyn
assert.deepEqual(removed, ['shape-2', 'shape-3']);
});
-test('clear forgets an externally evicted marker without removing a missing entity', async () => {
+test('user observes that clear forgets an externally evicted marker without removing a missing entity', async () => {
+ // Given the chart candles, interval and marker ownership
const {
dom,
shapes,
removed,
evictShape,
} = createChartDom();
+ // When findBearishBollingerChartTarget processes the configured inputs
const target = findBearishBollingerChartTarget(dom.window.document, 'BTRUSDT');
const layer = createBearishBollingerMarkerLayer(target);
@@ -1388,26 +1688,32 @@ test('clear forgets an externally evicted marker without removing a missing enti
layer.clear();
+ // Then user observes that clear forgets an externally evicted marker without removing a missing entity
assert.equal(layer.size, 0);
assert.equal(shapes.size, 0);
assert.deepEqual(removed, []);
});
-test('excludes an unclosed reversal breakout bar from detector input', () => {
+test('user excludes an unclosed reversal breakout bar from detector input', () => {
+ // Given the chart candles, interval and marker ownership
const exported = exportResult([
{ 0: 60, 1: 10, 2: 12, 3: 9, 4: 11 },
{ 0: 120, 1: 11, 2: 14, 3: 10, 4: 13 },
]);
+ // When parseClosedTradingViewBars processes the configured inputs
const bars = parseClosedTradingViewBars(exported, {
resolutionSeconds: 60,
observedAtSeconds: 150,
});
+ // Then user excludes an unclosed reversal breakout bar from detector input
assert.deepEqual(bars, [{ time: 60, open: 10, high: 12, low: 9, close: 11 }]);
});
-test('rejects an abnormal marker count before mutating the existing layer', async () => {
+test('user rejects an abnormal marker count before mutating the existing layer', async () => {
+ // Given the chart candles, interval and marker ownership
const { dom, shapes, removed } = createChartDom();
+ // When findBearishBollingerChartTarget processes the configured inputs
const target = findBearishBollingerChartTarget(dom.window.document, 'BTRUSDT');
const layer = createBearishBollingerMarkerLayer(target);
const isCurrent = () => true;
@@ -1424,6 +1730,7 @@ test('rejects an abnormal marker count before mutating the existing layer', asyn
}),
);
+ // Then user rejects an abnormal marker count before mutating the existing layer
await assert.rejects(
layer.render(excessive, { isCurrent }),
/marker limit exceeded/,
@@ -1432,8 +1739,10 @@ test('rejects an abnormal marker count before mutating the existing layer', asyn
assert.deepEqual(removed, []);
});
-test('applies the marker limit to the combined bullish and bearish layer', async () => {
+test('user applies the marker limit to the combined bullish and bearish layer', async () => {
+ // Given the chart candles, interval and marker ownership
const { dom, chart, shapes, removed, createdOptions, propertyUpdates } = createChartDom();
+ // When findBearishBollingerChartTarget processes the configured inputs
const target = findBearishBollingerChartTarget(dom.window.document, 'BTRUSDT');
let yields = 0;
const layer = createBollingerMarkerLayer(target, { yieldToBrowser: async () => { yields += 1; } });
@@ -1445,7 +1754,9 @@ test('applies the marker limit to the combined bullish and bearish layer', async
markerPrice: 10,
}));
- assert.equal(await layer.render(signals, { isCurrent: () => true }), true);
+ const observedResult = await layer.render(signals, { isCurrent: () => true });
+ // Then user applies the marker limit to the combined bullish and bearish layer
+ assert.equal(observedResult, true);
assert.equal(shapes.size, MAX_BOLLINGER_MARKERS);
const reads = { handles: 0, points: 0, properties: 0 };
@@ -1492,20 +1803,33 @@ function batchSignals() {
}));
}
-test('a real render batch yields a browser task before finishing', async () => {
+test('user observes that a real render batch yields a browser task before finishing', async (t) => {
+ // Given the chart candles, interval and marker ownership
+ t.mock.timers.enable({ apis: ['setTimeout'] });
const fixture = createChartDom();
+ // When findBearishBollingerChartTarget processes the configured inputs
const target = findBearishBollingerChartTarget(fixture.dom.window.document, 'BTRUSDT');
const layer = createBollingerMarkerLayer(target);
- const task = layer.render(batchSignals(), { isCurrent: () => true });
- await new Promise((resolve) => setTimeout(resolve, 0));
+ let completed = false;
+ const task = layer.render(batchSignals(), { isCurrent: () => true }).then(result => { completed = true; return result; });
+ await observeStrategyCondition(() => fixture.shapes.size > 0, 'first render batch');
+ // Then user observes that a real render batch yields a browser task before finishing
assert.ok(fixture.shapes.size > 0 && fixture.shapes.size <= 32);
+ assert.equal(completed, false, 'microtasks alone cannot resume the default browser-task yield');
+ for (let batch = 0; batch < 64 && !completed; batch += 1) {
+ t.mock.timers.tick(0);
+ await new Promise(setImmediate);
+ }
+ assert.equal(completed, true, 'each explicit browser task advances the bounded render');
assert.equal(await task, true);
assert.equal(fixture.shapes.size, 64);
});
for (const reason of ['stale', 'busy', 'clear']) {
- test(`a ${reason} transition during a render yield stops the old batch`, async () => {
+ test(`user observes that a ${reason} transition during a render yield stops the old batch`, async () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom();
+ // When findBearishBollingerChartTarget processes the configured inputs
const target = findBearishBollingerChartTarget(fixture.dom.window.document, 'BTRUSDT');
let current = true;
let busy = false;
@@ -1525,6 +1849,7 @@ for (const reason of ['stale', 'busy', 'clear']) {
detectSignals: batchSignals,
renderSignals: (signals) => layer.render(signals, { isCurrent: () => current }),
});
+ // Then user observes that a the selected case transition during a render yield stops the old batch
assert.ok(countAtYield > 0 && countAtYield <= 32);
assert.equal(fixture.createdOptions.length, countAtYield);
assert.equal(fixture.propertyUpdates.length, countAtYield);
@@ -1533,8 +1858,10 @@ for (const reason of ['stale', 'busy', 'clear']) {
});
}
-test('a marker evicted during a yield is recreated from the refreshed shape list', async () => {
+test('user observes that a marker evicted during a yield is recreated from the refreshed shape list', async () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom();
+ // When findBearishBollingerChartTarget processes the configured inputs
const target = findBearishBollingerChartTarget(fixture.dom.window.document, 'BTRUSDT');
let evict = false;
let evicted = null;
@@ -1547,6 +1874,7 @@ test('a marker evicted during a yield is recreated from the refreshed shape list
},
});
const signals = batchSignals();
+ // Then user observes that a marker evicted during a yield is recreated from the refreshed shape list
assert.equal(await layer.render(signals, { isCurrent: () => true }), true);
evict = true;
assert.equal(await layer.render(signals, { isCurrent: () => true }), true);
@@ -1557,7 +1885,8 @@ test('a marker evicted during a yield is recreated from the refreshed shape list
assert.deepEqual(fixture.removed, []);
});
-test('production monitor does not commit a batch interrupted by an interval switch', async () => {
+test('user observes that production monitor does not commit a batch interrupted by an interval switch', async () => {
+ // Given the chart candles, interval and marker ownership
const fixture = createChartDom();
const harness = createMonitorHarness(fixture, {
detectBollingerSignals: batchSignals,
@@ -1570,7 +1899,9 @@ test('production monitor does not commit a batch interrupted by an interval swit
{ 0: 3600, 1: 10, 2: 12, 3: 9, 4: 11 },
{ 0: 3660, 1: 10, 2: 12, 3: 9, 4: 11 },
]);
+ // When harness.tick processes the configured inputs
await harness.tick();
+ // Then user observes that production monitor does not commit a batch interrupted by an interval switch
assert.ok(fixture.shapes.size > 0 && fixture.shapes.size <= 32);
assert.equal(harness.monitor.context.lastProcessedClosedBarsWindowKey, null);
assert.equal(harness.monitor.context.lastProcessedClosedBarsContentSnapshot, null);
@@ -1580,8 +1911,10 @@ test('production monitor does not commit a batch interrupted by an interval swit
assert.equal(fixture.shapes.size, 0);
});
-test('preserves the full per-direction capacity when both directions are present', async () => {
+test('user preserves the full per-direction capacity when both directions are present', async () => {
+ // Given the chart candles, interval and marker ownership
const { dom, shapes } = createChartDom();
+ // When findBearishBollingerChartTarget processes the configured inputs
const target = findBearishBollingerChartTarget(dom.window.document, 'BTRUSDT');
const layer = createBollingerMarkerLayer(target);
const bearishSignals = Array.from(
@@ -1606,27 +1939,34 @@ test('preserves the full per-direction capacity when both directions are present
},
], { isCurrent: () => true });
+ // Then user preserves the full per-direction capacity when both directions are present
assert.equal(shapes.size, MAX_BOLLINGER_MARKERS_PER_DIRECTION + 1);
});
-test('removes a shifted marker and fails the alignment contract', async () => {
+test('user removes a shifted marker and fails the alignment contract', async () => {
+ // Given the chart candles, interval and marker ownership
const { dom, shapes, removed } = createChartDom({ shiftSeconds: -60 });
+ // When findBearishBollingerChartTarget processes the configured inputs
const target = findBearishBollingerChartTarget(dom.window.document, 'BTRUSDT');
const layer = createBearishBollingerMarkerLayer(target);
- await assert.rejects(
- layer.render(
+ const observedResult = layer.render(
[{ id: 'setup:warning', type: 'warning', time: 120, markerPrice: 10 }],
{ isCurrent: () => true },
- ),
+ );
+ // Then user removes a shifted marker and fails the alignment contract
+ await assert.rejects(
+ observedResult,
/time alignment failed: expected 120, received 60/,
);
assert.equal(shapes.size, 0);
assert.deepEqual(removed, ['shape-1']);
});
-test('clear removes a marker whose asynchronous creation finishes late', async () => {
+test('user observes that clear removes a marker whose asynchronous creation finishes late', async () => {
+ // Given the chart candles, interval and marker ownership
const { dom, shapes, removed, releaseCreate } = createChartDom({ deferredCreate: true });
+ // When findBearishBollingerChartTarget processes the configured inputs
const target = findBearishBollingerChartTarget(dom.window.document, 'BTRUSDT');
const layer = createBearishBollingerMarkerLayer(target);
const renderPromise = layer.render([
@@ -1637,13 +1977,16 @@ test('clear removes a marker whose asynchronous creation finishes late', async (
layer.clear();
releaseCreate();
+ // Then user observes that clear removes a marker whose asynchronous creation finishes late
assert.equal(await renderPromise, false);
assert.equal(shapes.size, 0);
assert.deepEqual(removed, ['shape-1']);
});
-test('removes a marker whose target changes while asynchronous creation is pending', async () => {
+test('user removes a marker whose target changes while asynchronous creation is pending', async () => {
+ // Given the chart candles, interval and marker ownership
const { dom, shapes, removed, releaseCreate } = createChartDom({ deferredCreate: true });
+ // When findBearishBollingerChartTarget processes the configured inputs
const target = findBearishBollingerChartTarget(dom.window.document, 'BTRUSDT');
const layer = createBearishBollingerMarkerLayer(target);
let current = true;
@@ -1655,6 +1998,7 @@ test('removes a marker whose target changes while asynchronous creation is pendi
current = false;
releaseCreate();
+ // Then user removes a marker whose target changes while asynchronous creation is pending
assert.equal(await renderPromise, false);
assert.equal(shapes.size, 0);
assert.deepEqual(removed, ['shape-1']);
diff --git a/test/dom/binance-trading-data-footer.test.js b/test/dom/binance-trading-data-footer.test.js
index f21aca2..e606f56 100644
--- a/test/dom/binance-trading-data-footer.test.js
+++ b/test/dom/binance-trading-data-footer.test.js
@@ -1,56 +1,25 @@
import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
import test from 'node:test';
-import vm from 'node:vm';
-import { JSDOM } from 'jsdom';
+import { activateTradingData, createDataPanelHost } from '../helpers/data-media-migration-host.js';
-const source = readFileSync(new URL('../../src/binance-trading-data/index.user.js', import.meta.url), 'utf8');
-
-function declaration(name) {
- const start = source.indexOf(`function ${name}(`);
- assert.notEqual(start, -1);
- const brace = source.indexOf('{', start);
- let depth = 0;
- for (let index = brace; index < source.length; index += 1) {
- if (source[index] === '{') depth += 1;
- if (source[index] === '}') depth -= 1;
- if (depth === 0) return source.slice(start, index + 1);
- }
- assert.fail('function declaration must be complete');
-}
-
-function harness(t) {
- const dom = new JSDOM('');
- t.after(() => dom.window.close());
+async function harness(t) {
const updatedAt = new Date(2026, 8, 12, 12, 34, 56).getTime();
- let now = updatedAt;
- t.mock.method(Date, 'now', () => now);
- const context = vm.createContext({
- document: dom.window.document, window: dom.window, Date,
- PANEL_ID: 'jh-binance-trading-data-panel', PANEL_WIDTH: 240,
- C: { bg: '#fff', border: '#ddd', sub: '#666', text: '#111' },
- lastUpdateTs: updatedAt,
- injectFlashStyle() {}, normalizeSavedPosition: () => null,
- loadPosition: () => null, loadCollapsed: () => false,
- keepPanelInViewport() {}, savePanelPosition() {}, cleanupPanelDrag() {},
- setupDrag() {}, setupCollapseAndClose() {}, cleanupPanelUnload() {},
- });
- vm.runInContext(declaration('ensurePanel'), context);
- vm.runInContext(declaration('updateFooter'), context);
- const panel = context.ensurePanel();
- const footer = panel.querySelector('#jh-binance-trading-data-panel-footer');
- context.updateFooter(footer);
- return { context, footer, window: dom.window, updatedAt, setNow: value => { now = value; } };
+ const host = createDataPanelHost(t, 'trading', { now: updatedAt });
+ await host.start();
+ await activateTradingData(host);
+ return { ...host, footer: host.element('footer'), updatedAt };
}
-test('sixty elapsed-time updates preserve the footer elements and update the displayed seconds', t => {
- const h = harness(t);
+test('user keeps the footer elements while sixty clock updates advance displayed seconds', { timeout: 5_000 }, async t => {
+ // Given the complete trading panel has rendered a recorded update timestamp
+ const h = await harness(t);
const row = h.footer.firstElementChild;
const labels = [...row.children];
- for (let second = 1; second <= 60; second += 1) {
- h.setNow(h.updatedAt + second * 1000);
- h.context.updateFooter(h.footer);
- }
+
+ // When its real one-second business timer runs sixty times on the controlled clock
+ for (let second = 1; second <= 60; second += 1) h.clock.tick(1_000);
+
+ // Then both label elements are retained while the displayed age reaches sixty seconds
assert.equal(h.footer.firstElementChild, row);
assert.equal(row.children[0], labels[0]);
assert.equal(row.children[1], labels[1]);
@@ -58,20 +27,38 @@ test('sixty elapsed-time updates preserve the footer elements and update the dis
assert.equal(labels[1].textContent, '60秒前');
});
-test('a repeated render in the same second produces no footer DOM mutation', t => {
- const h = harness(t);
- const observer = new h.window.MutationObserver(() => {});
+test('user receives a same-second refresh without any footer DOM mutation', { timeout: 5_000 }, async t => {
+ // Given an observed footer has just rendered its initial data timestamp
+ const h = await harness(t);
+ const records = [];
+ const observer = new h.window.MutationObserver(mutations => records.push(...mutations));
observer.observe(h.footer, { childList: true, subtree: true, characterData: true });
- h.context.updateFooter(h.footer);
+ t.after(() => observer.disconnect());
+
+ // When returning to the tab fetches and renders new data within the same second
+ h.setHidden(true);
+ h.setHidden(false);
+ await activateTradingData(h);
+
+ // Then the repeated render leaves the unchanged timestamp and age nodes untouched
+ assert.equal(records.length, 0);
assert.equal(observer.takeRecords().length, 0);
- observer.disconnect();
+ assert.equal(h.footer.firstElementChild.children[1].textContent, '0秒前');
});
-test('new data updates the retained timestamp label and resets elapsed seconds', t => {
- const h = harness(t);
- h.context.lastUpdateTs = h.updatedAt + 300_000;
- h.setNow(h.context.lastUpdateTs);
- h.context.updateFooter(h.footer);
- assert.equal(h.footer.children[0].children[0].textContent, '更新于 12:39:56');
- assert.equal(h.footer.children[0].children[1].textContent, '0秒前');
+test('user sees the retained timestamp label advance and elapsed seconds reset with new data', { timeout: 5_000 }, async t => {
+ // Given an existing footer label belongs to a completed initial refresh
+ const h = await harness(t);
+ const label = h.footer.firstElementChild.children[0];
+ h.setHidden(true);
+
+ // When the user returns five minutes later and the next complete response renders
+ h.clock.setTime(h.updatedAt + 300_000);
+ h.setHidden(false);
+ await activateTradingData(h);
+
+ // Then the same label displays the new timestamp and a zero-second age
+ assert.equal(h.footer.firstElementChild.children[0], label);
+ assert.equal(label.textContent, '更新于 12:39:56');
+ assert.equal(h.footer.firstElementChild.children[1].textContent, '0秒前');
});
diff --git a/test/dom/brooks-export-entrypoint.test.js b/test/dom/brooks-export-entrypoint.test.js
new file mode 100644
index 0000000..999256f
--- /dev/null
+++ b/test/dom/brooks-export-entrypoint.test.js
@@ -0,0 +1,393 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { afterDataMediaResponseTurn } from '../helpers/data-media-migration-host.js';
+import { createMediaHost } from '../helpers/data-media-migration-media-host.js';
+import { buildBrooksMediaIndexExportFilename } from '../../src/m3u8-downloader/brooks-exporter.js';
+import { buildBrooksMediaIndexRecord } from '../../src/m3u8-downloader/brooks-record.js';
+
+const stateKey = 'jh-userscripts:brooks-media-index-export';
+const indexUrl = 'https://www.brookstradingcourse.com/main-course-videos/';
+const links = [
+ 'https://www.brookstradingcourse.com/price-action-fundamentals/video-01-terminology/?ref=course',
+ 'https://www.brookstradingcourse.com/price-action-fundamentals/video-02-chart-basics/',
+ 'https://www.brookstradingcourse.com/bonus-videos/trading-patterns-on-the-open/',
+];
+const courseHtml = 'BTC PAF 01 Terminology | Brooks Trading Course';
+
+function courseHost(t, selectedLinks = links, options = {}) {
+ return createMediaHost(t, {
+ url: indexUrl,
+ markup: selectedLinks.map((url, index) => `Lesson ${index + 1}`).join(''),
+ ...options,
+ });
+}
+
+function stateOf(host) {
+ return JSON.parse(host.window.localStorage.getItem(stateKey));
+}
+
+function reportFrameMedia(host, videoId) {
+ const frame = host.document.querySelector('iframe');
+ const pageUrl = new URL(frame.src).searchParams.get('jhBrooksPageUrl');
+ host.window.dispatchEvent(new host.window.MessageEvent('message', {
+ origin: 'https://iframe.mediadelivery.net', source: frame.contentWindow,
+ data: {
+ type: 'jh-userscripts:m3u8-detected',
+ url: `https://vz-fixture.b-cdn.net/${videoId}/1920x1080/video.m3u8?expires=100&title=Lesson+${videoId}`,
+ referer: frame.src,
+ brooksExport: { pageUrl, title: `Lesson ${videoId}` },
+ },
+ }));
+}
+
+async function downloadPayload(host) {
+ const count = host.downloads.length;
+ host.element('brooks-media-export-download').click();
+ assert.equal(host.downloads.length, count + 1);
+ return JSON.parse(await host.downloads.at(-1).blob.text());
+}
+
+test('user receives an explicit error for an invalid media export filename timestamp', () => {
+ // Given the public filename contract receives a non-date export timestamp
+ const timestamp = 'not-a-timestamp';
+
+ // When the filename is requested for that invalid timestamp
+ const createFilename = () => buildBrooksMediaIndexExportFilename(timestamp);
+
+ // Then the error retains the rejected input instead of creating an unusable filename
+ assert.throws(createFilename, { message: 'Invalid Brooks media export timestamp: not-a-timestamp' });
+});
+
+for (const outcome of ['paused', 'discarded']) {
+ test(`user keeps collection ${outcome} when a successful page already queued the next microtask`, { timeout: 5_000 }, async t => {
+ // Given one completed page is about to advance a two-course collection
+ const host = courseHost(t, links.slice(0, 2));
+ await host.start();
+ host.element('brooks-media-export-primary').click();
+ host.network.requests[0].respond(courseHtml);
+
+ // When the user pauses or discards immediately after media success and before the queued continuation
+ reportFrameMedia(host, 'first');
+ host.element('brooks-media-export-primary').click();
+ if (outcome === 'discarded') host.element('brooks-media-export-reset').click();
+ await afterDataMediaResponseTurn();
+ host.clock.tick(45_000);
+
+ // Then the pending continuation cannot start the next page or recreate discarded work
+ assert.equal(host.network.requests.length, 1);
+ assert.equal(host.document.querySelectorAll('iframe').length, 0);
+ if (outcome === 'paused') {
+ const state = stateOf(host);
+ assert.equal(state.index, 1);
+ assert.deepEqual(state.records.map(record => record.index), [0]);
+ assert.equal(state.running, false);
+ assert.equal(state.stopped, true);
+ assert.equal(host.element('brooks-media-export-primary').textContent, '继续');
+ } else {
+ assert.equal(host.window.localStorage.getItem(stateKey), null);
+ assert.equal(host.element('brooks-media-export-status').textContent, '发现 2 个课程视频');
+ assert.equal(host.element('brooks-media-export-primary').textContent, '开始');
+ }
+ });
+}
+
+test('user rediscovers current courses when saved progress disappears before resume', { timeout: 5_000 }, async t => {
+ // Given a two-course export is paused after retaining its first successful page
+ const host = courseHost(t, links.slice(0, 2));
+ await host.start();
+ host.element('brooks-media-export-primary').click();
+ host.network.requests[0].respond(courseHtml);
+ reportFrameMedia(host, 'first');
+ await afterDataMediaResponseTurn();
+ host.element('brooks-media-export-primary').click();
+ assert.equal(stateOf(host).index, 1);
+ assert.equal(host.element('brooks-media-export-primary').textContent, '继续');
+
+ // When saved progress is cleared outside the panel and a new course appears before resume
+ host.window.localStorage.removeItem(stateKey);
+ const link = host.document.createElement('a');
+ link.href = links[2];
+ link.textContent = 'New lesson';
+ host.document.body.append(link);
+ host.element('brooks-media-export-primary').click();
+
+ // Then resume begins a fresh collection from all current links and the first original page
+ const state = stateOf(host);
+ assert.deepEqual(state.links, links);
+ assert.equal(state.index, 0);
+ assert.deepEqual(state.records, []);
+ assert.deepEqual(state.failures, []);
+ assert.deepEqual(host.network.requests.map(request => request.url), [links[0], links[1], links[0]]);
+ assert.equal(host.element('brooks-media-export-primary').textContent, '暂停');
+});
+
+test('user ignores empty and unrelated page records while preserving the pending course', { timeout: 5_000 }, async t => {
+ // Given the exporter accepts same-origin records only for its actively pending page
+ const host = courseHost(t, links.slice(0, 2));
+ await host.start();
+ const record = buildBrooksMediaIndexRecord({ pageUrl: links[1], title: 'Second lesson', m3u8Url: 'https://vz-fixture.b-cdn.net/second/video.m3u8' });
+ const send = data => host.window.dispatchEvent(new host.window.MessageEvent('message', { origin: new URL(indexUrl).origin, data }));
+ send({ type: 'jh-userscripts:brooks-media-index-record', record });
+ assert.equal(host.window.localStorage.getItem(stateKey), null);
+ host.element('brooks-media-export-primary').click();
+ host.network.requests[0].respond(courseHtml);
+ const before = host.window.localStorage.getItem(stateKey);
+ const frame = host.document.querySelector('iframe');
+
+ // When empty data and another course's record arrive before the actual pending media
+ send(null);
+ send({ type: 'jh-userscripts:brooks-media-index-record', record });
+ assert.equal(host.window.localStorage.getItem(stateKey), before);
+ assert.equal(host.document.querySelector('iframe'), frame);
+ reportFrameMedia(host, 'first');
+ await afterDataMediaResponseTurn();
+
+ // Then only the matching first course advances the collection to its second original URL
+ assert.deepEqual(stateOf(host).records.map(item => ({ index: item.index, url: item.url })), [{ index: 0, url: links[0] }]);
+ assert.deepEqual(host.network.requests.map(request => request.url), links.slice(0, 2));
+ assert.equal(stateOf(host).index, 1);
+});
+
+for (const saved of [
+ { name: 'unreadable JSON', value: '{', error: true },
+ { name: 'an unsupported schema', value: '{"schemaVersion":1}', error: false },
+]) {
+ test(`user starts from discovered courses when saved progress contains ${saved.name}`, { timeout: 5_000 }, async t => {
+ // Given stored export data cannot be used by the current documented schema
+ const host = courseHost(t, links, { storage: { [stateKey]: saved.value } });
+
+ // When the complete userscript initializes its course controls
+ await host.start();
+
+ // Then the page remains idle and reports the newly discovered course count
+ assert.equal(host.element('brooks-media-export-status').textContent, '发现 3 个课程视频');
+ assert.equal(host.element('brooks-media-export-primary').textContent, '开始');
+ assert.equal(host.network.requests.length, 0);
+ assert.equal(host.logs.some(args => args[0] === 'Unable to load Brooks media export state:'), saved.error);
+ });
+}
+
+test('user receives an explicit explanation when exporting before a collection exists', { timeout: 5_000 }, async t => {
+ // Given the course panel has not started a collection
+ const host = courseHost(t);
+ await host.start();
+
+ // When export is requested and a hidden retry control is invoked programmatically
+ host.element('brooks-media-export-download').click();
+ host.element('brooks-media-export-retry-failed').click();
+
+ // Then no request or artifact is created without an eligible export state
+ assert.deepEqual(host.alerts, ['没有可导出的 Brooks 视频与字幕清单']);
+ assert.equal(host.downloads.length, 0);
+ assert.equal(host.network.requests.length, 0);
+ assert.equal(host.window.localStorage.getItem(stateKey), null);
+});
+
+test('user can inspect an empty collection without mistaking it for a completed course export', { timeout: 5_000 }, async t => {
+ // Given the index page currently contains no course video links
+ const host = courseHost(t, []);
+ await host.start();
+
+ // When the user starts collection and downloads its JSON result
+ host.element('brooks-media-export-primary').click();
+ const payload = await downloadPayload(host);
+
+ // Then the empty artifact carries zero work and never claims course completion
+ assert.equal(host.network.requests.length, 0);
+ assert.deepEqual({
+ total: payload.total, done: payload.done, completed: payload.completed,
+ missingIndexes: payload.missingIndexes, elapsedMs: payload.elapsedMs,
+ records: payload.records, failures: payload.failures,
+ }, { total: 0, done: 0, completed: false, missingIndexes: [], elapsedMs: 0, records: [], failures: [] });
+ assert.equal(host.element('brooks-media-export-reset').style.display, 'none');
+ assert.equal(host.blobs.size, 0);
+});
+
+for (const failure of [
+ { name: 'an HTTP rejection', respond: request => request.respond('Unavailable', 503), error: 'page fetch failed: 503' },
+ { name: 'a network error', respond: request => request.fail(), error: 'page fetch network error' },
+ { name: 'a page without its media iframe', respond: request => request.respond('Login required'), error: 'Bunny embed iframe not found' },
+]) {
+ test(`user exports the original failed course identity after ${failure.name}`, { timeout: 5_000 }, async t => {
+ // Given one course URL retains its navigation query in the collection
+ const host = courseHost(t, [links[0]]);
+ await host.start();
+ host.element('brooks-media-export-primary').click();
+
+ // When the page request completes through the specified failure boundary
+ host.clock.tick(2_000);
+ failure.respond(host.network.requests[0]);
+ const payload = await downloadPayload(host);
+
+ // Then the visible reason, exported failure, and original index agree
+ assert.equal(host.element('brooks-media-export-status').textContent, `已完成 1/1 | 成功 0 | 失败 1\n耗时: 2s\n最近失败: ${failure.error}\n请点“重试失败”；仍失败再导出清单 JSON`);
+ assert.deepEqual(payload.failures, [{ ok: false, index: 0, url: links[0], error: failure.error }]);
+ assert.deepEqual(stateOf(host).links, [links[0]]);
+ assert.equal(payload.completed, true);
+ assert.equal(payload.elapsedMs, 2_000);
+ assert.equal(payload.nextIndex, 1);
+ assert.deepEqual(payload.missingIndexes, []);
+ assert.equal(host.element('brooks-media-export-retry-failed').style.display, '');
+ assert.equal(host.document.querySelectorAll('iframe').length, 0);
+ assert.equal(host.downloads[0].name, 'brooks-media-index-2026-09-16T000002Z.json');
+ assert.deepEqual(host.revoked, [host.downloads[0].url]);
+ });
+}
+
+for (const late of [
+ { name: 'successful', respond: request => request.respond(courseHtml) },
+ { name: 'failed', respond: request => request.respond('Unavailable', 503) },
+]) {
+ test(`user times out an unresolved course at 45 seconds and ignores its late ${late.name} page response`, { timeout: 5_000 }, async t => {
+ // Given the page request stays pending while the exporter displays waiting time
+ const host = courseHost(t, [links[0]]);
+ await host.start();
+ host.element('brooks-media-export-primary').click();
+ const page = host.network.requests[0];
+
+ // When the declared deadline arrives before a late HTTP completion
+ host.clock.tick(44_999);
+ assert.deepEqual(stateOf(host).failures, []);
+ assert.match(host.element('brooks-media-export-status').textContent, /等待 44s/);
+ host.clock.tick(1);
+ late.respond(page);
+ await afterDataMediaResponseTurn();
+
+ // Then only one timeout outcome is kept and stale callbacks create no media frame
+ const state = stateOf(host);
+ assert.deepEqual(state.failures, [{ ok: false, index: 0, url: links[0], error: 'm3u8 detection timeout' }]);
+ assert.equal(state.activeElapsedMs, 45_000);
+ assert.equal(state.running, false);
+ assert.equal(host.network.requests.length, 1);
+ assert.equal(host.document.querySelectorAll('iframe').length, 0);
+ });
+}
+
+for (const late of [
+ { name: 'successful', respond: request => request.respond(courseHtml) },
+ { name: 'failed', respond: request => request.fail() },
+]) {
+ test(`user keeps paused progress unchanged when its former page request completes as ${late.name}`, { timeout: 5_000 }, async t => {
+ // Given a course request is still pending after two seconds of active collection
+ const host = courseHost(t, [links[0]]);
+ await host.start();
+ host.element('brooks-media-export-primary').click();
+ host.clock.tick(2_000);
+ const page = host.network.requests[0];
+
+ // When the user pauses before the old request completes and its old timeout expires
+ host.element('brooks-media-export-primary').click();
+ late.respond(page);
+ host.clock.tick(60_000);
+ await afterDataMediaResponseTurn();
+
+ // Then neither the late callback nor paused wall time changes the saved work
+ const state = stateOf(host);
+ assert.deepEqual({ index: state.index, records: state.records, failures: state.failures, elapsed: state.activeElapsedMs }, {
+ index: 0, records: [], failures: [], elapsed: 2_000,
+ });
+ assert.equal(state.stopped, true);
+ assert.equal(host.element('brooks-media-export-primary').textContent, '继续');
+ assert.equal(host.document.querySelectorAll('iframe').length, 0);
+ assert.equal(host.network.requests.length, 1);
+ });
+}
+
+test('user downloads partial and complete course JSON with active runtime excluding the pause', { timeout: 5_000 }, async t => {
+ // Given two original course links begin a collection at a known timestamp
+ const host = courseHost(t, links.slice(0, 2));
+ await host.start();
+ host.element('brooks-media-export-primary').click();
+ host.network.requests[0].respond(courseHtml);
+ host.clock.tick(1_250);
+ reportFrameMedia(host, 'first');
+ await afterDataMediaResponseTurn();
+ host.clock.tick(750);
+
+ // When the user exports a paused result, waits a minute, and finishes the remaining page
+ host.element('brooks-media-export-primary').click();
+ const partial = await downloadPayload(host);
+ host.clock.tick(60_000);
+ host.element('brooks-media-export-primary').click();
+ host.network.requests.at(-1).respond(courseHtml);
+ host.clock.tick(3_000);
+ reportFrameMedia(host, 'second');
+ await afterDataMediaResponseTurn();
+ const complete = await downloadPayload(host);
+
+ // Then downloaded content preserves identity and counts only five seconds of active work
+ assert.deepEqual({ done: partial.done, completed: partial.completed, missing: partial.missingIndexes, elapsed: partial.elapsedMs, stopped: partial.stopped }, {
+ done: 1, completed: false, missing: [1], elapsed: 2_000, stopped: true,
+ });
+ assert.deepEqual({ done: complete.done, completed: complete.completed, missing: complete.missingIndexes, elapsed: complete.elapsedMs, stopped: complete.stopped }, {
+ done: 2, completed: true, missing: [], elapsed: 5_000, stopped: false,
+ });
+ assert.deepEqual(complete.records.map(record => ({ index: record.index, url: record.url })), links.slice(0, 2).map((url, index) => ({ index, url })));
+ assert.equal(complete.records[0].m3u8, 'https://vz-fixture.b-cdn.net/first/1920x1080/video.m3u8?expires=100');
+ assert.equal(complete.records[0].cn, 'https://vz-fixture.b-cdn.net/first/captions/CN.vtt?expires=100');
+ assert.equal(complete.records[0].en, 'https://vz-fixture.b-cdn.net/first/captions/EN.vtt?expires=100');
+ assert.equal(complete.records[0].output, 'Lesson first.%(ext)s');
+ assert.equal(complete.elapsedText, '5s');
+ assert.equal(complete.startedAt, '2026-09-16T00:00:00.000Z');
+ assert.equal(complete.exportedAt, '2026-09-16T00:01:05.000Z');
+ assert.equal(host.downloads[1].name, 'brooks-media-index-2026-09-16T000105Z.json');
+ assert.equal(host.element('brooks-media-export-reset').style.display, 'none');
+ assert.equal(host.blobs.size, 0);
+ assert.equal(host.revoked.length, 2);
+});
+
+test('user retries two failed original indexes without collecting the successful middle course again', { timeout: 5_000 }, async t => {
+ // Given the first and last course fail around one successfully collected middle course
+ const host = courseHost(t);
+ await host.start();
+ host.element('brooks-media-export-primary').click();
+ host.network.requests[0].respond('Unavailable', 503);
+ host.network.requests[1].respond(courseHtml);
+ reportFrameMedia(host, 'middle');
+ await afterDataMediaResponseTurn();
+ host.network.requests[2].fail();
+ assert.deepEqual(stateOf(host).failures.map(failure => failure.index), [0, 2]);
+
+ // When the completed export retries both failures successfully
+ host.element('brooks-media-export-retry-failed').click();
+ host.network.requests[3].respond(courseHtml);
+ reportFrameMedia(host, 'first');
+ await afterDataMediaResponseTurn();
+ assert.deepEqual(stateOf(host).retryQueue, [2]);
+ host.network.requests[4].respond(courseHtml);
+ reportFrameMedia(host, 'last');
+ await afterDataMediaResponseTurn();
+ const payload = await downloadPayload(host);
+
+ // Then the artifact retains all original indexes with no duplicate success or retry queue
+ assert.deepEqual(host.network.requests.map(request => request.url), [...links, links[0], links[2]]);
+ assert.deepEqual(payload.records.map(record => record.index), [1, 0, 2]);
+ assert.deepEqual(payload.failures, []);
+ assert.deepEqual(payload.missingIndexes, []);
+ assert.equal(payload.nextIndex, 3);
+ assert.equal(payload.completed, true);
+ assert.equal(Object.hasOwn(stateOf(host), 'retryQueue'), false);
+ assert.equal(host.element('brooks-media-export-retry-failed').style.display, 'none');
+});
+
+test('user discards paused collection without allowing the abandoned page response to restart it', { timeout: 5_000 }, async t => {
+ // Given a page is paused with an outstanding HTML request
+ const host = courseHost(t, [links[0]]);
+ await host.start();
+ host.element('brooks-media-export-primary').click();
+ const page = host.network.requests[0];
+ host.element('brooks-media-export-primary').click();
+
+ // When reset discards the state before the abandoned page response arrives
+ host.element('brooks-media-export-reset').click();
+ page.respond(courseHtml);
+ host.clock.tick(45_000);
+ await afterDataMediaResponseTurn();
+
+ // Then reset remains idle and neither the response nor old deadline recreates progress
+ assert.equal(host.window.localStorage.getItem(stateKey), null);
+ assert.equal(host.element('brooks-media-export-status').textContent, '发现 1 个课程视频');
+ assert.equal(host.element('brooks-media-export-primary').textContent, '开始');
+ assert.equal(host.network.requests.length, 1);
+ assert.equal(host.document.querySelectorAll('iframe').length, 0);
+});
diff --git a/test/dom/coinmarketcap-valuation-helper.test.js b/test/dom/coinmarketcap-valuation-helper.test.js
index 502ca70..deb888a 100644
--- a/test/dom/coinmarketcap-valuation-helper.test.js
+++ b/test/dom/coinmarketcap-valuation-helper.test.js
@@ -1,9 +1,12 @@
import assert from 'node:assert/strict';
import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import vm from 'node:vm';
import test from 'node:test';
import { JSDOM } from 'jsdom';
-const source = readFileSync(new URL('../../scripts/coinmarketcap-valuation-helper.user.js', import.meta.url), 'utf8');
+const artifact = new URL('../../scripts/coinmarketcap-valuation-helper.user.js', import.meta.url);
+const source = readFileSync(artifact, 'utf8');
function harness(t, markup, { pathname = '/zh/currencies/bitcoin/' } = {}) {
const dom = new JSDOM(markup, {
@@ -20,16 +23,16 @@ function harness(t, markup, { pathname = '/zh/currencies/bitcoin/' } = {}) {
measured.push(this);
return {
width: this.closest('[data-hidden]') ? 0 : 120, height: 24,
- top: Number(this.closest('[data-top]')?.dataset.top ?? 200), left: 100,
+ top: Number(this.closest('[data-top]')?.dataset.top ?? 200),
+ left: Number(this.closest('[data-left]')?.dataset.left ?? 100),
};
};
- window.getComputedStyle = () => ({ display: 'block', visibility: 'visible' });
const query = document.querySelectorAll.bind(document);
document.querySelectorAll = selector => {
if (selector === 'span,p,div') scans += 1;
return query(selector);
};
- window.eval(source);
+ new vm.Script(source, { filename: fileURLToPath(artifact) }).runInContext(dom.getInternalVMContext());
async function flush() {
for (let round = 0; round < 5; round += 1) {
await Promise.resolve();
@@ -46,9 +49,12 @@ const cards = `
FDV$456M
`;
-test('valuation matching never reads layout for unrelated quote rows', t => {
+test('user observes that valuation matching never reads layout for unrelated quote rows', t => {
+ // Given the CoinMarketCap page contains valuation labels and surrounding quotes
const background = Array.from({ length: 200 }, (_, index) => `
${index}
Price
`).join('');
+ // When the valuation helper handles the page content
const h = harness(t, cards + background);
+ // Then valuation matching never reads layout for unrelated quote rows
assert.equal(h.document.querySelector('#cap').textContent, '流通市值');
assert.equal(h.document.querySelector('#fdv').textContent, 'FDV/总估值');
assert.equal(h.document.querySelectorAll('.jh-cmc-valuation-highlight').length, 2);
@@ -56,13 +62,16 @@ test('valuation matching never reads layout for unrelated quote rows', t => {
assert.ok(h.measured.length <= 12, `only the two metric scopes/cards need layout, received ${h.measured.length}`);
});
-test('independent price mutation batches share one rename scan per animation frame', async t => {
+test('user observes that independent price mutation batches share one rename scan per animation frame', async t => {
+ // Given the CoinMarketCap page contains valuation labels and surrounding quotes
const h = harness(t, cards + '
123
');
const initialScans = h.scans;
+ // When the valuation helper handles the page content
for (let index = 0; index < 10; index += 1) {
h.document.querySelector('#price').firstChild.data = String(index);
await Promise.resolve();
}
+ // Then independent price mutation batches share one rename scan per animation frame
assert.equal(h.scans, initialScans);
assert.equal(h.frames.length, 1);
await h.flush();
@@ -70,8 +79,12 @@ test('independent price mutation batches share one rename scan per animation fra
assert.equal(h.document.querySelector('#cap').textContent, '流通市值');
});
-test('text-only labels still react to a delayed nearby value and replacement labels', async t => {
- const h = harness(t, '
市值
');
+test('user observes that text-only labels still react to a delayed nearby value and replacement labels', async t => {
+ // Given the supplied input describes this data scenario
+ const scenarioInput = '
市值
';
+ // When the text-only labels still react to a delayed nearby value and replacement labels
+ const h = harness(t, scenarioInput);
+ // Then text-only labels still react to a delayed nearby value and replacement labels
assert.equal(h.document.querySelector('#label').textContent, '市值');
h.document.querySelector('#value').textContent = '$123';
await h.flush();
@@ -81,24 +94,91 @@ test('text-only labels still react to a delayed nearby value and replacement lab
assert.equal(h.document.querySelector('#label').textContent, 'FDV/总估值');
});
-test('hidden and out-of-area labels retain the original text', t => {
- const h = harness(t, `
+test('user observes that hidden and out-of-area labels retain the original text', t => {
+ // Given the supplied input describes this data scenario
+ const scenarioInput = `
市值$123M
FDV$456M
- `);
+ `;
+ // When the hidden and out-of-area labels retain the original text
+ const h = harness(t, scenarioInput);
+ // Then hidden and out-of-area labels retain the original text
assert.equal(h.document.querySelector('#hidden').textContent, '市值');
assert.equal(h.document.querySelector('#lower').textContent, 'FDV');
});
-test('a queued scan validates the current route before changing labels', async t => {
+test('user observes that a queued scan validates the current route before changing labels', async t => {
+ // Given the CoinMarketCap page contains valuation labels and surrounding quotes
const h = harness(t, cards);
h.document.querySelector('#cap').textContent = '市值';
await Promise.resolve();
h.window.history.pushState({}, '', '/zh/watchlist/');
+ // When the valuation helper handles the page content
await h.flush();
+ // Then a queued scan validates the current route before changing labels
assert.equal(h.document.querySelector('#cap').textContent, '市值');
h.window.history.pushState({}, '', '/zh/currencies/ethereum/');
h.document.querySelector('#cap').textContent = '市值';
await h.flush();
assert.equal(h.document.querySelector('#cap').textContent, '流通市值');
});
+
+test('user sees explainer labels renamed in definition terms and plain parent containers', t => {
+ // Given the statistics use supported layouts without group-item cards
+ const markup = '
市值
$123M
'
+ + 'FDV';
+
+ // When the full valuation helper scans the visible statistics
+ const h = harness(t, markup);
+
+ // Then explainer identity renames both labels without creating unsupported card highlights
+ assert.equal(h.document.getElementById('term').firstChild.textContent, '流通市值');
+ assert.equal(h.document.getElementById('plain').textContent, 'FDV/总估值');
+ assert.equal(h.document.querySelectorAll('.jh-cmc-valuation-highlight').length, 0);
+});
+
+test('user keeps explainer content intact while its neighboring metric label is renamed', t => {
+ // Given nested explainer text repeats the label without a nearby numeric metric
+ const markup = '
FDVFDV
FDV';
+
+ // When explainer-based matching identifies the surrounding metric label
+ const h = harness(t, markup);
+
+ // Then the icon and its descendants preserve their content while the actual label changes
+ assert.equal(h.document.getElementById('explainer').firstChild.textContent, 'FDV');
+ assert.equal(h.document.getElementById('nested').textContent, 'FDV');
+ assert.equal(h.document.getElementById('actual').textContent, 'FDV/总估值');
+ assert.equal(h.document.querySelectorAll('.jh-cmc-valuation-highlight').length, 1);
+});
+
+test('user retains hidden and misplaced explainer labels outside the visible statistics area', t => {
+ // Given explainer scopes are hidden, above the statistics, or beyond their right edge
+ const markup = '市值$1M'
+ + 'FDV$2M'
+ + '市值$3M';
+
+ // When the full helper applies its visibility and page-area rules
+ const h = harness(t, markup);
+
+ // Then labels outside the intended rendered area remain unchanged and unhighlighted
+ assert.equal(h.document.getElementById('hidden').textContent, '市值');
+ assert.equal(h.document.getElementById('above').textContent, 'FDV');
+ assert.equal(h.document.getElementById('right').textContent, '市值');
+ assert.equal(h.document.querySelectorAll('.jh-cmc-valuation-highlight').length, 0);
+});
+
+test('user can match a unit-valued metric while preserving whitespace and its embedded icon', t => {
+ // Given a text-only metric has a unit-suffixed value and separate whitespace text nodes
+ const markup = '
\n FDV
123M';
+
+ // When the helper renames the direct nonempty label node
+ const h = harness(t, markup);
+
+ // Then the metric changes without replacing the icon or whitespace surrounding it
+ const label = h.document.getElementById('label');
+ assert.equal(label.firstChild.textContent, ' \n');
+ assert.equal(label.lastChild.textContent, 'FDV/总估值');
+ assert.equal(label.children.length, 1);
+ assert.equal(label.firstElementChild.id, 'icon');
+ assert.equal(label.parentElement.classList.contains('jh-cmc-valuation-highlight'), true);
+});
diff --git a/test/dom/data-media-remaining-boundaries.test.js b/test/dom/data-media-remaining-boundaries.test.js
new file mode 100644
index 0000000..97a9d5f
--- /dev/null
+++ b/test/dom/data-media-remaining-boundaries.test.js
@@ -0,0 +1,338 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+ activateTradingData, afterDataMediaResponseTurn, cmcDetail, completeCmcData,
+ completeTradingBatch, createDataPanelHost, tradingDataset,
+} from '../helpers/data-media-migration-host.js';
+import { createMediaHost } from '../helpers/data-media-migration-media-host.js';
+
+const courseUrl = 'https://www.brookstradingcourse.com/price-action-fundamentals/video-01-terminology/';
+const indexUrl = 'https://www.brookstradingcourse.com/main-course-videos/';
+const exportStateKey = 'jh-userscripts:brooks-media-index-export';
+
+async function completeInitialPanel(host, kind) {
+ if (kind === 'trading') await activateTradingData(host);
+ else await completeCmcData(host);
+ await afterDataMediaResponseTurn();
+}
+
+/** Release HTTP fixture responses without requiring a mounted render target. */
+async function respondCmcDetail(host, detail) {
+ const request = await host.network.waitForRequest(request => !request.settled && request.url.pathname.endsWith('/detail'));
+ request.respond({ data: detail });
+ const holders = await host.network.waitForRequest(request => !request.settled && request.url.pathname.endsWith('/show_holders'));
+ holders.respond({ data: { showFlag: true, count: 10_000 } });
+ await afterDataMediaResponseTurn();
+}
+
+function detachOutputSlots(host, kind) {
+ return (kind === 'trading' ? ['symbol', 'rows', 'composite', 'footer'] : ['symbol', 'rows', 'footer']).map(suffix => {
+ const element = host.element(suffix);
+ const parent = element.parentNode;
+ const html = element.innerHTML;
+ element.remove();
+ return { element, parent, html };
+ });
+}
+
+for (const kind of ['trading', 'cmc']) {
+ test(`user restores current ${kind} values after page changes temporarily detach all output slots`, { timeout: 5_000 }, async t => {
+ // Given a complete panel has its output elements detached by a page DOM update
+ const host = createDataPanelHost(t, kind);
+ await host.start();
+ await completeInitialPanel(host, kind);
+ const panel = host.panel();
+ const detached = detachOutputSlots(host, kind);
+
+ // When an ordinary refresh completes while those output elements are absent
+ if (kind === 'trading') {
+ host.setHidden(false);
+ const time = await host.network.waitForRequest(request => !request.settled && request.url.pathname.endsWith('/time'));
+ time.respond({ serverTime: Date.now() });
+ await completeTradingBatch(host, tradingDataset(Date.now(), { oi: 3_000_000 }));
+ } else {
+ host.element('refresh').click();
+ await respondCmcDetail(host, cmcDetail({ statistics: { ...cmcDetail().statistics, price: 70_000 } }));
+ }
+ await afterDataMediaResponseTurn();
+ host.clock.tick(1_000);
+
+ // Then detached output remains untouched and available header controls keep working
+ assert.deepEqual(detached.map(({ element }) => element.innerHTML), detached.map(({ html }) => html));
+ assert.equal(host.panel(), panel);
+ assert.deepEqual(host.errors, []);
+ host.element('collapse').click();
+ assert.equal(host.element('body').style.display, 'none');
+
+ // When the page restores its elements and the next refresh supplies new current values
+ for (const { element, parent } of detached) parent.append(element);
+ host.element('collapse').click();
+ if (kind === 'trading') {
+ host.setHidden(false);
+ await activateTradingData(host, tradingDataset(Date.now(), { oi: 4_000_000 }));
+ } else {
+ host.element('refresh').click();
+ await completeCmcData(host, cmcDetail({ statistics: { ...cmcDetail().statistics, price: 80_000 } }), { map: false });
+ }
+ await afterDataMediaResponseTurn();
+
+ // Then the restored panel renders the newest response with one mounted panel and no stale mutation
+ assert.equal(host.element('body').style.display, 'block');
+ assert.equal(host.document.querySelectorAll(`#${host.panelId}`).length, 1);
+ assert.match(host.element('rows').textContent, kind === 'trading' ? /4\.00M ▲/ : /价格\$8万/);
+ assert.match(host.element('footer').textContent, kind === 'trading' ? /更新于/ : /CMC data-api/);
+ assert.deepEqual(host.errors, []);
+ });
+
+ for (const viewport of [
+ { name: 'document client dimensions', clientWidth: 640, clientHeight: 360 },
+ { name: 'an unavailable viewport', clientWidth: 0, clientHeight: 0 },
+ ]) {
+ test(`user retains a finite ${kind} panel position with ${viewport.name}`, { timeout: 5_000 }, async t => {
+ // Given window dimensions are temporarily zero while the document reports the specified viewport
+ const prefix = kind === 'trading' ? 'jh_binance_trading_data' : 'jh_binance_cmc_data';
+ const host = createDataPanelHost(t, kind, { storage: { [`${prefix}_pos`]: '{"left":900,"top":900}' } });
+ Object.defineProperties(host.window, { innerWidth: { value: 0, configurable: true }, innerHeight: { value: 0, configurable: true } });
+ Object.defineProperties(host.document.documentElement, {
+ clientWidth: { value: viewport.clientWidth, configurable: true },
+ clientHeight: { value: viewport.clientHeight, configurable: true },
+ });
+
+ // When the entrypoint renders and receives resize notifications before and after route removal
+ await host.start();
+ await completeInitialPanel(host, kind);
+ host.window.dispatchEvent(new host.window.Event('resize'));
+ const position = JSON.parse(host.window.localStorage.getItem(`${prefix}_pos`));
+ const panelPosition = { left: host.panel().style.left, top: host.panel().style.top };
+ host.navigate('/zh-CN/futures');
+ host.window.dispatchEvent(new host.window.Event('resize'));
+
+ // Then real JSDOM zero-area layout persists finite origin coordinates and removal creates no replacement
+ assert.deepEqual(position, { left: 0, top: 0 });
+ assert.deepEqual(panelPosition, { left: '0px', top: '0px' });
+ assert.equal(host.panel(), null);
+ assert.equal(host.window.localStorage.getItem(`${prefix}_pos`), '{"left":0,"top":0}');
+ assert.deepEqual(host.errors, []);
+ });
+ }
+
+ test(`user keeps one scheduled ${kind} refresh after a repeated visible notification`, { timeout: 5_000 }, async t => {
+ // Given the panel is already visible with an active route watcher and business schedule
+ const host = createDataPanelHost(t, kind);
+ await host.start();
+ await completeInitialPanel(host, kind);
+
+ // When a repeated browser visibility event refreshes the still-active panel
+ host.setHidden(false);
+ if (kind === 'trading') await activateTradingData(host);
+ else await completeCmcData(host, cmcDetail(), { map: false });
+ await afterDataMediaResponseTurn();
+ const count = host.network.requests.length;
+ const deadline = kind === 'trading' ? 305_000 : 30_000;
+ host.clock.tick(deadline - 1);
+ assert.equal(host.network.requests.length, count);
+ host.clock.tick(1);
+ if (kind === 'trading') await completeTradingBatch(host, tradingDataset(Date.now()));
+ else await respondCmcDetail(host, cmcDetail());
+ await afterDataMediaResponseTurn();
+
+ // Then the next deadline issues one batch and retains exactly one current panel
+ assert.equal(host.network.requests.length, count + (kind === 'trading' ? 7 : 2));
+ assert.equal(host.document.querySelectorAll(`#${host.panelId}`).length, 1);
+ assert.equal(host.element('symbol').textContent, kind === 'trading' ? 'BTCUSDT' : 'BTC #1');
+ assert.deepEqual(host.errors, []);
+ });
+}
+
+test('user recovers a CMC panel after both API and page errors arrive while output slots are detached', { timeout: 5_000 }, async t => {
+ // Given the current panel was rendered before the page removed its output slots
+ const host = createDataPanelHost(t, 'cmc');
+ await host.start();
+ await completeCmcData(host);
+ const detached = detachOutputSlots(host, 'cmc');
+
+ // When a manual refresh receives failures from the API and its page-snapshot recovery boundary
+ host.element('refresh').click();
+ const api = await host.network.waitForRequest(request => !request.settled && request.url.pathname.endsWith('/detail'));
+ api.respond({}, 503);
+ const page = await host.network.waitForRequest(request => request.url.hostname === 'coinmarketcap.com');
+ page.respond('Unavailable', 502);
+ await afterDataMediaResponseTurn();
+
+ // Then neither failed response writes into detached slots or destroys working controls
+ assert.deepEqual(detached.map(({ element }) => element.innerHTML), detached.map(({ html }) => html));
+ assert.equal(host.element('refresh').isConnected, true);
+ assert.deepEqual(host.errors, []);
+
+ // When the page restores its outputs and the next manual refresh succeeds
+ for (const { element, parent } of detached) parent.append(element);
+ host.element('refresh').click();
+ await completeCmcData(host, cmcDetail(), { map: false });
+ await afterDataMediaResponseTurn();
+
+ // Then current rows and API provenance replace the former detached output
+ assert.equal(host.element('symbol').textContent, 'BTC #1');
+ assert.match(host.element('rows').textContent, /价格\$6万/);
+ assert.equal(host.element('footer').querySelector('a').textContent, 'CMC data-api');
+});
+
+test('user receives an asset identification error when CMC supplies a numeric symbol instead of its string contract', { timeout: 5_000 }, async t => {
+ // Given a numeric-only Binance asset has a current-symbol CMC map request
+ const host = createDataPanelHost(t, 'cmc', { path: '/futures/4USDT' });
+ await host.start();
+ const request = await host.network.waitForRequest(request => request.url.pathname.endsWith('/map'));
+
+ // When the upstream row has a numeric symbol even though its ID and slug are present
+ request.respond({ data: [{ id: 4, symbol: 4, slug: 'four', is_active: 1 }] });
+ await host.rendered(() => host.element('rows').textContent.includes('无法识别当前合约'));
+
+ // Then invalid mapping data remains a visible failure and never triggers a guessed detail request
+ assert.equal(host.element('rows').textContent, '读取失败无法识别当前合约');
+ assert.equal(host.element('symbol').textContent, '4USDT');
+ assert.equal(host.network.requests.length, 1);
+});
+
+test('user keeps trading data operational when the page temporarily has no head element', { timeout: 5_000 }, async t => {
+ // Given the page body survives a host DOM update that removes its head
+ const host = createDataPanelHost(t, 'trading');
+ host.document.head.remove();
+
+ // When the entrypoint creates its panel and completes the current-symbol data requests
+ await host.start();
+ await activateTradingData(host);
+
+ // Then style installation uses the remaining document root and complete indicators remain usable
+ assert.equal(host.document.getElementById('jh-trading-data-flash-style').parentNode, host.document.documentElement);
+ assert.equal(host.element('rows').children.length, 8);
+ assert.match(host.element('composite').textContent, /偏多 7:0/);
+ assert.deepEqual(host.errors, []);
+});
+
+test('user sees unavailable trading data after the bounded retry also fails without an error message', { timeout: 5_000 }, async t => {
+ // Given the current open-interest request rejects with an Error whose message is empty
+ const host = createDataPanelHost(t, 'trading');
+ await host.start();
+ host.network.requests[0].respond({ serverTime: Date.now() });
+ await host.network.waitForRequest(request => request.url.pathname.endsWith('/fundingRate'));
+ const dataset = tradingDataset(Date.now());
+ const missing = host.network.requests.find(request => request.url.pathname.endsWith('/openInterestHist'));
+ const failure = new Error('');
+
+ // When its allowed retry also fails while all other data endpoints complete
+ missing.fail(failure);
+ for (const request of host.network.requests.filter(request => !request.settled)) {
+ request.respond(dataset[request.url.pathname.split('/').at(-1)]);
+ }
+ const retry = await host.network.waitForRequest(request => !request.settled && request.url.pathname.endsWith('/openInterestHist'));
+ retry.fail(failure);
+ await host.rendered(panel => panel?.querySelector('[data-role="updated-at"]')?.textContent.startsWith('更新于'));
+
+ // Then the missing row cannot vote and the complete error object remains available for diagnosis
+ assert.equal(host.element('rows').firstElementChild.children[1].textContent, '--');
+ assert.match(host.element('composite').textContent, /偏多 6:0/);
+ assert.equal(host.network.requests.filter(request => request.url.pathname.endsWith('/openInterestHist')).length, 2);
+ assert.equal(host.errors.at(-1).at(-1), failure);
+});
+
+test('user records a valid untitled Bunny detection without inventing its missing referer or title', { timeout: 5_000 }, async t => {
+ // Given the exporter has loaded an untitled current course into its actual media iframe
+ const host = createMediaHost(t, { url: indexUrl, markup: `Lesson` });
+ await host.start();
+ host.element('brooks-media-export-primary').click();
+ host.network.requests[0].respond('');
+ const frame = host.document.querySelector('iframe');
+
+ // When that frame reports a supported playlist without optional title or referer metadata
+ host.window.dispatchEvent(new host.window.MessageEvent('message', {
+ source: frame.contentWindow, origin: 'https://iframe.mediadelivery.net',
+ data: { type: 'jh-userscripts:m3u8-detected', url: 'https://media.example/video-id/playlist.m3u8', brooksExport: { pageUrl: courseUrl } },
+ }));
+ await afterDataMediaResponseTurn();
+ host.element('brooks-media-export-download').click();
+ const payload = JSON.parse(await host.downloads[0].blob.text());
+
+ // Then the original course index completes with empty optional fields and correct media identities
+ assert.equal(payload.completed, true);
+ assert.deepEqual(payload.records.map(record => ({ index: record.index, title: record.title, mediaTitle: record.mediaTitle, referer: record.referer, videoId: record.videoId })), [
+ { index: 0, title: '', mediaTitle: '', referer: '', videoId: 'video-id' },
+ ]);
+ assert.equal(payload.records[0].cn, 'https://media.example/video-id/captions/CN.vtt');
+ assert.equal(payload.records[0].en, 'https://media.example/video-id/captions/EN.vtt');
+ assert.equal(host.network.requests.length, 1);
+ assert.equal(host.document.querySelectorAll('iframe').length, 0);
+});
+
+test('user gets an explicit failed course record for an empty successful HTML response', { timeout: 5_000 }, async t => {
+ // Given collection is waiting for one authenticated-course HTML response
+ const host = createMediaHost(t, { url: indexUrl, markup: `Lesson` });
+ await host.start();
+ host.element('brooks-media-export-primary').click();
+
+ // When the HTTP request succeeds but contains no page content
+ host.network.requests[0].respond('');
+ await afterDataMediaResponseTurn();
+ const state = JSON.parse(host.window.localStorage.getItem(exportStateKey));
+
+ // Then empty content remains a recoverable embed-discovery failure with the original course identity
+ assert.deepEqual(state.failures, [{ ok: false, index: 0, url: courseUrl, error: 'Bunny embed iframe not found' }]);
+ assert.deepEqual(state.records, []);
+ assert.equal(state.running, false);
+ assert.equal(host.element('brooks-media-export-retry-failed').style.display, '');
+ assert.equal(host.document.querySelectorAll('iframe').length, 0);
+});
+
+test('user does not start a retry when saved failures have no valid original course index', { timeout: 5_000 }, async t => {
+ // Given a completed saved collection contains a failure referring outside its original link list
+ const saved = {
+ schemaVersion: 2, links: [courseUrl], index: 1, records: [],
+ failures: [{ ok: false, index: 9, url: courseUrl, error: 'Interrupted import' }],
+ running: false, stopped: false, activeElapsedMs: 2_000,
+ };
+ const host = createMediaHost(t, { url: indexUrl, markup: `Lesson`, storage: { [exportStateKey]: JSON.stringify(saved) } });
+ await host.start();
+
+ // When the user invokes the visible retry action for the saved failures
+ host.element('brooks-media-export-retry-failed').click();
+ await afterDataMediaResponseTurn();
+
+ // Then no unrelated course request starts and the failure remains available for inspection
+ assert.equal(host.network.requests.length, 0);
+ assert.deepEqual(JSON.parse(host.window.localStorage.getItem(exportStateKey)), saved);
+ assert.match(host.element('brooks-media-export-status').textContent, /最近失败: Interrupted import/);
+});
+
+test('user completes export after page changes remove optional action controls', { timeout: 5_000 }, async t => {
+ // Given one pending course keeps its status display while the host removes optional controls
+ const host = createMediaHost(t, { url: indexUrl, markup: `Lesson` });
+ await host.start();
+ host.element('brooks-media-export-primary').click();
+ for (const suffix of ['primary', 'retry-failed', 'download', 'reset', 'reset-help']) host.element(`brooks-media-export-${suffix}`).remove();
+
+ // When an empty response completes as a declared per-course failure
+ host.network.requests[0].respond('');
+ await afterDataMediaResponseTurn();
+
+ // Then status and persisted progress still reflect that outcome without recreating removed controls
+ assert.match(host.element('brooks-media-export-status').textContent, /已完成 1\/1 \| 成功 0 \| 失败 1/);
+ assert.equal(JSON.parse(host.window.localStorage.getItem(exportStateKey)).failures[0].error, 'Bunny embed iframe not found');
+ assert.equal(host.element('brooks-media-export-dom').querySelectorAll('button').length, 0);
+});
+
+test('user keeps export progress when the page removes the whole status panel during collection', { timeout: 5_000 }, async t => {
+ // Given collection has already issued its original-course request
+ const host = createMediaHost(t, { url: indexUrl, markup: `Lesson` });
+ await host.start();
+ host.element('brooks-media-export-primary').click();
+
+ // When the page removes the exporter UI before the network failure arrives
+ host.element('brooks-media-export-dom').remove();
+ host.network.requests[0].fail();
+ await afterDataMediaResponseTurn();
+ const state = JSON.parse(host.window.localStorage.getItem(exportStateKey));
+
+ // Then the failure remains persisted and collection stops without silently recreating the removed UI
+ assert.equal(host.element('brooks-media-export-dom'), null);
+ assert.deepEqual(state.failures, [{ ok: false, index: 0, url: courseUrl, error: 'page fetch network error' }]);
+ assert.equal(state.running, false);
+ assert.equal(host.network.requests.length, 1);
+});
diff --git a/test/dom/m3u8-download-entrypoint.test.js b/test/dom/m3u8-download-entrypoint.test.js
new file mode 100644
index 0000000..ba4db37
--- /dev/null
+++ b/test/dom/m3u8-download-entrypoint.test.js
@@ -0,0 +1,292 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { afterDataMediaResponseTurn } from '../helpers/data-media-migration-host.js';
+import { createMediaHost, createMediaRequestBoundary } from '../helpers/data-media-migration-media-host.js';
+
+const mediaUrl = 'https://cdn.example/lesson/playlist.m3u8?token=fixture&expires=100';
+const playlist = '#EXTM3U\n#EXTINF:10,\nsegment.ts\n';
+
+async function detectedMedia(t, options = {}) {
+ const host = createMediaHost(t, { markup: `Fixture lesson`, ...options });
+ await host.start();
+ assert.equal(host.network.requests.length, 1);
+ host.network.requests[0].respond(playlist);
+ return host;
+}
+
+test('user receives XHR ready-state and load events with the declared response body', () => {
+ // Given a request boundary records the original open arguments and callback events
+ const { MediaXHR, requests } = createMediaRequestBoundary();
+ const request = new MediaXHR();
+ const events = [];
+ request.onreadystatechange = () => events.push(['ready', request.readyState]);
+ request.onload = () => events.push(['load', request.status, request.responseText]);
+
+ // When the modeled network completes the pending request
+ request.open('GET', mediaUrl, true);
+ request.send(null);
+ request.receiveHeaders(206);
+ request.receiveChunk('#EXTM3U\n');
+ request.respond(playlist, 206);
+
+ // Then the same request owns its arguments, body, response, and ordered completion events
+ assert.equal(requests[0], request);
+ assert.deepEqual(request.args, ['GET', mediaUrl, true]);
+ assert.equal(request.body, null);
+ assert.deepEqual(events, [['ready', 2], ['ready', 3], ['ready', 4], ['load', 206, playlist]]);
+ assert.throws(() => request.respond('duplicate'), /delivered only once/);
+});
+
+test('user receives playlist controls only after the HTTP response body completes', { timeout: 5_000 }, async t => {
+ // Given the page has discovered a playlist whose response is still streaming
+ const host = createMediaHost(t, { markup: `Fixture lesson` });
+ await host.start();
+ const request = host.network.requests[0];
+
+ // When response headers and a recognizable partial body arrive before final completion
+ request.receiveHeaders(200);
+ request.receiveChunk(playlist);
+ assert.equal(host.element('m3u8-download-dom'), null);
+ request.respond(playlist);
+ host.element('m3u8-copy-command').click();
+
+ // Then one completed playlist produces usable controls and the original media command
+ assert.equal(host.document.querySelectorAll('#m3u8-download-dom').length, 1);
+ assert.equal(host.copied[0], `yt-dlp --referer 'https://njav.com/watch/fixture' -N 16 -o 'Fixture lesson.%(ext)s' '${mediaUrl}'`);
+ assert.equal(host.network.requests.length, 1);
+});
+
+test('user keeps successful captions and receives the declared error when another caption returns HTTP 503', { timeout: 5_000 }, async t => {
+ // Given the installed downloader has recognized the page's complete playlist
+ const host = await detectedMedia(t);
+ const caption = 'WEBVTT\n\n00:00:00.000 --> 00:00:01.000\nFixture\n';
+
+ // When the user starts injection and only the Chinese caption endpoint fails
+ host.element('m3u8-append').click();
+ host.network.requests.find(request => request.url.includes('/captions/CN.vtt')).respond('Unavailable', 503);
+ host.network.requests.find(request => request.url.includes('/captions/EN.vtt')).respond(caption);
+ await afterDataMediaResponseTurn();
+
+ // Then the request boundary reports its exact failure while the successful caption remains downloadable
+ const failures = host.logs.filter(args => args[0] === 'Error downloading caption:');
+ assert.equal(failures.length, 1);
+ assert.equal(failures[0][1].name, 'Error');
+ assert.equal(failures[0][1].message, 'Failed to download caption: 503');
+ assert.deepEqual(host.downloads.map(download => download.name), ['Fixture lesson.en.vtt']);
+ assert.equal(await host.downloads[0].blob.text(), caption);
+ assert.equal(host.blobs.size, 0);
+});
+
+for (const scenario of [
+ { name: 'an ordinary player', pageUrl: null, title: null },
+ { name: 'a course player with its title', pageUrl: 'https://www.brookstradingcourse.com/price-action-fundamentals/video-01-terminology/', title: 'Video 01 Terminology' },
+ { name: 'a course player without an export title', pageUrl: 'https://www.brookstradingcourse.com/price-action-fundamentals/video-01-terminology/', title: null },
+]) {
+ test(`user receives the detected playlist from ${scenario.name} through its actual parent window`, { timeout: 5_000 }, async t => {
+ // Given the installed entrypoint runs in a real nested player document
+ const parentUrl = 'https://www.brookstradingcourse.com/main-course-videos/';
+ const frameUrl = new URL('https://iframe.mediadelivery.net/embed/155631/fixture-video');
+ if (scenario.pageUrl) frameUrl.searchParams.set('jhBrooksPageUrl', scenario.pageUrl);
+ if (scenario.title) frameUrl.searchParams.set('jhBrooksTitle', scenario.title);
+ const host = createMediaHost(t, { parentUrl, url: frameUrl.href, markup: `Nested player` });
+ await host.start();
+ const received = new Promise(resolve => host.window.parent.addEventListener('message', event => resolve(event.data), { once: true }));
+
+ // When the nested player's complete playlist response reaches its page-context code
+ host.network.requests[0].respond(playlist);
+ host.clock.tick(0);
+ const message = await received;
+
+ // Then the parent receives the original referer and optional course identity with no child controls
+ assert.equal(message.type, 'jh-userscripts:m3u8-detected');
+ assert.equal(message.url, `${mediaUrl}&title=Nested+player`);
+ assert.equal(message.referer, frameUrl.href);
+ if (scenario.pageUrl) {
+ assert.equal(message.brooksExport.pageUrl, scenario.pageUrl);
+ assert.equal(message.brooksExport.title, scenario.title || '');
+ } else assert.equal(message.brooksExport, undefined);
+ assert.equal(host.parentMessages.length, 1);
+ assert.equal(host.element('m3u8-download-dom'), null);
+ assert.equal(host.downloads.length, 0);
+ });
+}
+
+test('user receives a Brooks media index record from the detected course video page', { timeout: 5_000 }, async t => {
+ // Given the full entrypoint runs on a course video page with a detected CDN playlist
+ const pageUrl = 'https://www.brookstradingcourse.com/price-action-fundamentals/video-01-terminology/?ref=course';
+ const source = 'https://vz-fixture.b-cdn.net/first/1920x1080/video.m3u8?expires=100';
+ const host = createMediaHost(t, { url: pageUrl, markup: `Video 01 Terminology` });
+ await host.start();
+ const received = new Promise(resolve => host.window.addEventListener('message', event => resolve(event.data), { once: true }));
+
+ // When the page recognizes its successful playlist and delivers the index notification
+ host.network.requests[0].respond(playlist);
+ host.clock.tick(0);
+ const message = await received;
+
+ // Then the emitted record preserves page identity and derives media and caption URLs from its actual host
+ assert.equal(message.type, 'jh-userscripts:brooks-media-index-record');
+ assert.equal(message.record.pageUrl, pageUrl);
+ assert.equal(message.record.referer, pageUrl);
+ assert.equal(message.record.title, 'Video 01 Terminology');
+ assert.equal(message.record.output, 'Video 01 Terminology.%(ext)s');
+ assert.equal(message.record.m3u8, source);
+ assert.equal(message.record.cn, 'https://vz-fixture.b-cdn.net/first/captions/CN.vtt?expires=100');
+ assert.equal(message.record.en, 'https://vz-fixture.b-cdn.net/first/captions/EN.vtt?expires=100');
+ assert.equal(host.element('m3u8-copy-command').style.display, 'block');
+});
+
+test('user sees download controls only for a successful recognized media playlist', { timeout: 5_000 }, async t => {
+ // Given three media elements point to a missing file, text page, and valid playlist
+ const host = createMediaHost(t, { markup: 'Fixture lesson' });
+ await host.start();
+
+ // When the first two requests fail recognition and the third returns HLS content
+ host.network.requests[0].respond('Not found', 404);
+ host.network.requests[1].respond('Not media');
+ assert.equal(host.element('m3u8-download-dom'), null);
+ host.network.requests[2].respond(playlist);
+
+ // Then exactly one control panel appears with a usable external download action
+ assert.equal(host.document.querySelectorAll('#m3u8-download-dom').length, 1);
+ assert.equal(host.element('m3u8-jump').style.display, 'block');
+ assert.equal(host.element('m3u8-download-dom').style.position, 'fixed');
+});
+
+for (const clipboard of ['native', 'rejected', 'absent']) {
+ test(`user copies a complete yt-dlp command with the ${clipboard} clipboard boundary`, { timeout: 5_000 }, async t => {
+ // Given a valid playlist retains its non-title query parameters
+ const host = await detectedMedia(t, { clipboard });
+
+ // When the user presses the actual copy-command button
+ host.element('m3u8-copy-command').click();
+ await afterDataMediaResponseTurn();
+
+ // Then the command preserves the media URL and referer and removes transient textareas
+ const copies = clipboard === 'native' ? host.copied : host.fallbackCopies;
+ assert.deepEqual(copies, [`yt-dlp --referer 'https://njav.com/watch/fixture' -N 16 -o 'Fixture lesson.%(ext)s' '${mediaUrl}'`]);
+ assert.equal(host.document.querySelector('textarea'), null);
+ assert.deepEqual(host.alerts, ['yt-dlp 命令已复制']);
+ });
+}
+
+test('user opens the external downloader with the complete detected source and can close its controls', { timeout: 5_000 }, async t => {
+ // Given a detected playlist has installed one visible control panel
+ const host = await detectedMedia(t);
+
+ // When the user opens the external action and dismisses the local controls
+ host.element('m3u8-jump').click();
+ host.element('m3u8-close').click();
+
+ // Then the opened URL retains the whole source and the dismissed panel is removed
+ assert.equal(host.opened.length, 1);
+ assert.equal(new URL(host.opened[0]).searchParams.get('source'), `${mediaUrl}&title=Fixture+lesson`);
+ assert.equal(host.element('m3u8-download-dom'), null);
+});
+
+test('user gets controls beside a visible video and cannot open a blocked external CDN', { timeout: 5_000 }, async t => {
+ // Given a visible video streams from a Bunny CDN with a page-specific title
+ const host = createMediaHost(t, { markup: '' });
+ await host.start();
+
+ // When the playlist is confirmed as media
+ host.network.requests[0].respond(playlist);
+
+ // Then the panel follows the video and the external download button remains hidden
+ assert.equal(host.document.querySelector('video').nextElementSibling.id, 'm3u8-download-dom');
+ assert.equal(host.element('m3u8-download-dom').style.position, 'relative');
+ assert.equal(host.element('m3u8-jump').style.display, 'none');
+ host.element('m3u8-copy-command').click();
+ assert.match(host.copied[0], /Video 04 Setup\.\%\(ext\)s/);
+});
+
+test('user toggles deduplicated MP4 downloads and downloads the selected filename', { timeout: 5_000 }, async t => {
+ // Given a media page contains two occurrences of the same MP4 URL
+ const url = 'https://cdn.example/lesson.mp4?expires=123';
+ const host = createMediaHost(t, { markup: `` });
+ await host.start();
+
+ // When the user opens the MP4 list, selects its item, and closes the list
+ host.element('mp4-show').click();
+ assert.equal(host.element('mp4-download-dom').children.length, 1);
+ host.element('mp4-download-dom').firstElementChild.click();
+ host.element('mp4-show').click();
+
+ // Then one named download is captured and toggling removes the list
+ assert.deepEqual(host.downloads.map(({ name, url }) => ({ name, url })), [{ name: 'lesson.mp4', url }]);
+ assert.equal(host.element('mp4-download-dom'), null);
+ assert.equal(host.element('mp4-show').textContent, 'MP4下载');
+});
+
+test('user intercepts media XHR without dropping original open arguments or reinstalling the wrapper', { timeout: 5_000 }, async t => {
+ // Given the installed userscript owns the page XMLHttpRequest wrapper
+ const host = createMediaHost(t);
+ await host.start();
+ const wrapped = host.window.XMLHttpRequest;
+
+ // When a host request opens a playlist URL through that wrapper
+ const xhr = new host.window.XMLHttpRequest();
+ xhr.open('GET', mediaUrl, false, undefined, undefined);
+ xhr.send('fixture request body');
+ host.network.requests[0].respond(playlist);
+ await host.start();
+
+ // Then the real request keeps every argument and reinjection preserves the wrapper
+ assert.deepEqual(xhr.args, ['GET', mediaUrl, false, undefined, undefined]);
+ assert.equal(xhr.body, 'fixture request body');
+ assert.equal(host.window.XMLHttpRequest, wrapped);
+ assert.equal(host.window.XMLHttpRequest.DONE, 4);
+ assert.equal(host.element('m3u8-copy-command').style.display, 'block');
+});
+
+test('user accepts only matching iframe media messages and anchors controls beside the referring frame', { timeout: 5_000 }, async t => {
+ // Given a page owns a known media iframe and no detected top-level playlist
+ const referer = 'https://iframe.mediadelivery.net/embed/1/fixture-video';
+ const host = createMediaHost(t, { markup: `Fixture lesson` });
+ await host.start();
+ const frame = host.document.querySelector('iframe');
+ const message = (origin, source, data) => host.window.dispatchEvent(new host.window.MessageEvent('message', { origin, source, data }));
+
+ // When unrelated messages are rejected before a matching frame reports media
+ message('https://attacker.example', frame.contentWindow, { type: 'jh-userscripts:m3u8-detected', url: mediaUrl });
+ message('https://iframe.mediadelivery.net', frame.contentWindow, { type: 'unrelated', url: mediaUrl });
+ assert.equal(host.element('m3u8-download-dom'), null);
+ message('https://iframe.mediadelivery.net', frame.contentWindow, { type: 'jh-userscripts:m3u8-detected', url: mediaUrl, referer });
+
+ // Then the panel follows the authenticated source frame and copies its referer
+ assert.equal(frame.nextElementSibling.id, 'm3u8-download-dom');
+ host.element('m3u8-copy-command').click();
+ assert.equal(host.copied[0], `yt-dlp --referer '${referer}' -N 16 -o 'Fixture lesson.%(ext)s' '${mediaUrl}'`);
+});
+
+test('user injects a sanitized downloader and receives captions from the detected media host', { timeout: 5_000 }, async t => {
+ // Given a recognized playlist provides the actual host and query parameters
+ const host = await detectedMedia(t);
+
+ // When the user injects the downloader and its modeled resources complete
+ host.element('m3u8-append').click();
+ const captions = host.network.requests.filter(request => request.url.includes('/captions/'));
+ assert.equal(captions.length, 2);
+ captions.forEach(request => request.respond('WEBVTT\n\n00:00:00.000 --> 00:00:01.000\nFixture\n'));
+ const html = '
// script注入window.fixtureDownloader = {url: \'\', // 在线链接\n}; // script注入';
+ host.network.requests.find(request => request.url.includes('index.html')).respond(html);
+ for (const filename of ['stream-saver.js', 'mux-mp4.js', 'aes-decryptor.js', 'vue.js']) {
+ const request = host.network.requests.find(request => request.url.endsWith(filename));
+ assert.ok(request, `the ${filename} request must follow the previous completion`);
+ request.respond('/* Offline library boundary. */');
+ }
+ await afterDataMediaResponseTurn();
+
+ // Then both caption downloads retain the query and the injected UI has no promotional nodes
+ assert.deepEqual(captions.map(request => request.url).sort(), [
+ 'https://cdn.example/lesson/captions/CN.vtt?token=fixture&expires=100',
+ 'https://cdn.example/lesson/captions/EN.vtt?token=fixture&expires=100',
+ ]);
+ assert.deepEqual(host.downloads.map(download => download.name).sort(), ['Fixture lesson.en.vtt', 'Fixture lesson.zh.vtt']);
+ assert.equal(await host.downloads[0].blob.text(), 'WEBVTT\n\n00:00:00.000 --> 00:00:01.000\nFixture\n');
+ assert.equal(host.element('fixture-downloader').querySelector('script,a'), null);
+ assert.equal(host.window.fixtureDownloader.url, `${mediaUrl}&title=Fixture+lesson`);
+ assert.equal(host.blobs.size, 0);
+ assert.equal(host.revoked.length, 2);
+ assert.deepEqual(host.alerts, ['注入成功，请滚动到页面底部']);
+});
diff --git a/test/dom/m3u8-media-scan.test.js b/test/dom/m3u8-media-scan.test.js
index ed507d5..131f4b0 100644
--- a/test/dom/m3u8-media-scan.test.js
+++ b/test/dom/m3u8-media-scan.test.js
@@ -41,17 +41,21 @@ async function harness(t, markup = '') {
return { window, document: window.document, frames, requests, scannedVideos, flush, get documentScans() { return documentScans; } };
}
-test('a source change scans only its owning video among 100 existing videos', async t => {
+test('user observes that a source change scans only its owning video among 100 existing videos', async t => {
+ // Given the media page contains the videos and source elements under observation
const h = await harness(t, Array.from({ length: 100 }, (_, index) => ``).join(''));
const video = h.document.querySelector('video');
video.firstChild.src = 'https://media.example/new.m3u8';
+ // When the scanner handles the specified media mutation
await h.flush();
+ // Then a source change scans only its owning video among 100 existing videos
assert.deepEqual(h.requests, ['https://media.example/new.m3u8']);
assert.deepEqual(h.scannedVideos, [video]);
assert.equal(h.documentScans, 0);
});
-test('separate mutations deduplicate videos and preserve all sources discovered in the frame', async t => {
+test('user observes that separate mutations deduplicate videos and preserve all sources discovered in the frame', async t => {
+ // Given the media page contains the videos and source elements under observation
const h = await harness(t, '');
const a = h.document.querySelector('#a');
const b = h.document.querySelector('#b');
@@ -60,69 +64,90 @@ test('separate mutations deduplicate videos and preserve all sources discovered
const sourceNode = Object.assign(h.document.createElement('source'), { src: 'https://media.example/alt.m3u8' });
a.appendChild(sourceNode);
b.src = 'https://media.example/b.m3u8';
+ // When the scanner handles the specified media mutation
await Promise.resolve();
+ // Then separate mutations deduplicate videos and preserve all sources discovered in the frame
assert.equal(h.frames.length, 1);
await h.flush();
assert.deepEqual(h.scannedVideos, [a, b]);
assert.deepEqual(h.requests.sort(), ['https://media.example/a.m3u8', 'https://media.example/alt.m3u8', 'https://media.example/b.m3u8']);
});
-test('added media subtrees are scanned without revisiting unrelated existing videos', async t => {
+test('user observes that added media subtrees are scanned without revisiting unrelated existing videos', async t => {
+ // Given the media page contains the videos and source elements under observation
const h = await harness(t, '');
const wrapper = h.document.createElement('div');
wrapper.innerHTML = '';
h.document.body.appendChild(wrapper);
+ // When the scanner handles the specified media mutation
await h.flush();
+ // Then added media subtrees are scanned without revisiting unrelated existing videos
assert.deepEqual(h.scannedVideos.map(video => video.id), ['new']);
assert.deepEqual(h.requests, ['https://media.example/added.m3u8']);
assert.equal(h.documentScans, 0);
});
-test('a video removed before the frame is not scanned or requested', async t => {
+test('user observes that a video removed before the frame is not scanned or requested', async t => {
+ // Given the media page contains the videos and source elements under observation
const h = await harness(t, '');
const video = h.document.querySelector('video');
video.src = 'https://media.example/removed.m3u8';
await Promise.resolve();
video.remove();
+ // When the scanner handles the specified media mutation
await h.flush();
+ // Then a video removed before the frame is not scanned or requested
assert.deepEqual(h.scannedVideos, []);
assert.deepEqual(h.requests, []);
});
-test('a queued video adopted into another document is no longer owned by this scanner', async t => {
+test('user observes that a queued video adopted into another document is no longer owned by this scanner', async t => {
+ // Given the media page contains the videos and source elements under observation
const h = await harness(t, '');
const video = h.document.querySelector('video');
video.src = 'https://media.example/moved.m3u8';
await Promise.resolve();
const otherDocument = h.document.implementation.createHTMLDocument('Other media document');
+ // When the scanner handles the specified media mutation
otherDocument.body.appendChild(video);
+ // Then a queued video adopted into another document is no longer owned by this scanner
assert.equal(video.isConnected, true);
await h.flush();
assert.deepEqual(h.requests, []);
});
-test('sources inside a newly inserted wrapper still queue their existing owning video', async t => {
+test('user observes that sources inside a newly inserted wrapper still queue their existing owning video', async t => {
+ // Given the media page contains the videos and source elements under observation
const h = await harness(t, '');
const wrapper = h.document.createElement('div');
wrapper.innerHTML = '';
h.document.querySelector('#owner').appendChild(wrapper);
+ // When the scanner handles the specified media mutation
await h.flush();
+ // Then sources inside a newly inserted wrapper still queue their existing owning video
assert.deepEqual(h.scannedVideos.map(video => video.id), ['owner']);
assert.deepEqual(h.requests, ['https://media.example/nested.m3u8']);
});
-test('non-media src mutations and text updates queue no media work', async t => {
+test('user observes that non-media src mutations and text updates queue no media work', async t => {
+ // Given the media page contains the videos and source elements under observation
const h = await harness(t, '
Old
');
h.document.querySelector('img').src = 'https://media.example/image.jpg';
h.document.querySelector('picture source').src = 'https://media.example/preview.webp';
h.document.querySelector('p').textContent = 'New';
+ // When the scanner handles the specified media mutation
await Promise.resolve();
+ // Then non-media src mutations and text updates queue no media work
assert.equal(h.frames.length, 0);
assert.deepEqual(h.scannedVideos, []);
});
-test('initial media discovery and later load discovery keep request deduplication', async t => {
- const h = await harness(t, '');
+test('user observes that initial media discovery and later load discovery keep request deduplication', async t => {
+ // Given the supplied input describes this media scenario
+ const scenarioInput = '';
+ // When the initial media discovery and later load discovery keep request deduplication
+ const h = await harness(t, scenarioInput);
+ // Then initial media discovery and later load discovery keep request deduplication
assert.deepEqual(h.requests, ['https://media.example/initial.m3u8']);
h.document.querySelector('video').setAttribute('src', 'https://media.example/initial.m3u8');
await h.flush();
diff --git a/test/helpers/data-media-migration-host.js b/test/helpers/data-media-migration-host.js
new file mode 100644
index 0000000..76acb95
--- /dev/null
+++ b/test/helpers/data-media-migration-host.js
@@ -0,0 +1,214 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import vm from 'node:vm';
+import { MessageChannel } from 'node:worker_threads';
+import { JSDOM } from 'jsdom';
+
+/** Observe an actual host mutation instead of assuming a render duration. */
+export function observeDom(window, predicate) {
+ if (predicate()) return Promise.resolve();
+ return new Promise(resolve => {
+ const observer = new window.MutationObserver(() => {
+ if (!predicate()) return;
+ observer.disconnect();
+ resolve();
+ });
+ observer.observe(window.document, { childList: true, subtree: true, attributes: true, characterData: true });
+ });
+}
+
+/** A delivered host task follows promise reactions without assuming their depth. */
+export function afterDataMediaResponseTurn() {
+ return new Promise(resolve => {
+ const { port1, port2 } = new MessageChannel();
+ port1.once('message', () => {
+ port1.close();
+ port2.close();
+ resolve();
+ });
+ port2.postMessage('response-turn-complete');
+ });
+}
+
+/** Node owns wall time and browser task timers; the page retains its real DOM. */
+export function installDataMediaClock(t, window, now = Date.UTC(2026, 8, 16, 0, 0, 0)) {
+ t.mock.timers.enable({ apis: ['Date', 'setTimeout', 'setInterval'], now });
+ window.Date = Date;
+ window.setTimeout = globalThis.setTimeout;
+ window.clearTimeout = globalThis.clearTimeout;
+ window.setInterval = globalThis.setInterval;
+ window.clearInterval = globalThis.clearInterval;
+ window.requestAnimationFrame = callback => window.setTimeout(() => callback(Date.now()), 16);
+ window.cancelAnimationFrame = id => window.clearTimeout(id);
+ return t.mock.timers;
+}
+
+/** Requests remain pending until the scenario supplies a modeled HTTP outcome. */
+export function createDataMediaNetwork() {
+ const requests = [];
+ const listeners = new Set();
+ function publish(request) {
+ requests.push(request);
+ for (const listener of listeners) listener();
+ }
+ function waitForRequest(predicate) {
+ const existing = requests.find(predicate);
+ if (existing) return Promise.resolve(existing);
+ return new Promise(resolve => {
+ const listener = () => {
+ const request = requests.find(predicate);
+ if (!request) return;
+ listeners.delete(listener);
+ resolve(request);
+ };
+ listeners.add(listener);
+ });
+ }
+ function fetch(url) {
+ return new Promise((resolve, reject) => {
+ const request = {
+ url: new URL(url), kind: 'fetch', settled: false,
+ respond(body, status = 200) {
+ assert.equal(request.settled, false, 'each HTTP request has one terminal outcome');
+ request.settled = true;
+ resolve({ ok: status >= 200 && status < 300, status, json: async () => body });
+ },
+ fail(error = new Error('fixture network unavailable')) {
+ assert.equal(request.settled, false);
+ request.settled = true;
+ reject(error);
+ },
+ };
+ publish(request);
+ });
+ }
+ function gmRequest(options) {
+ const request = {
+ url: new URL(options.url), kind: 'gm', options, settled: false,
+ respond(body, status = 200) {
+ assert.equal(request.settled, false, 'each GM request has one terminal outcome');
+ request.settled = true;
+ options.onload({ status, responseText: typeof body === 'string' ? body : JSON.stringify(body) });
+ },
+ fail(kind = 'error') {
+ assert.equal(request.settled, false);
+ request.settled = true;
+ assert.ok(['error', 'timeout'].includes(kind));
+ options[`on${kind}`]();
+ },
+ };
+ publish(request);
+ return { abort() { request.settled = true; } };
+ }
+ return { requests, fetch, gmRequest, waitForRequest };
+}
+
+export function createDataPanelHost(t, kind, {
+ path = '/zh-CN/futures/BTCUSDT', storage = {}, hidden = false,
+ now = Date.UTC(2026, 8, 16, 0, 0, 0),
+} = {}) {
+ assert.ok(['trading', 'cmc'].includes(kind));
+ const dom = new JSDOM('', {
+ url: `https://www.binance.com${path}`, runScripts: 'outside-only', pretendToBeVisual: true,
+ });
+ const { window } = dom;
+ const clock = installDataMediaClock(t, window, now);
+ const network = createDataMediaNetwork();
+ const errors = [];
+ window.fetch = network.fetch;
+ window.GM_xmlhttpRequest = network.gmRequest;
+ window.console.error = (...args) => { errors.push(args); };
+ Object.defineProperty(window.document, 'hidden', { configurable: true, get: () => hidden });
+ for (const [key, value] of Object.entries(storage)) window.localStorage.setItem(key, value);
+ const panelId = kind === 'trading' ? 'jh-binance-trading-data-panel' : 'jh-binance-cmc-data-panel';
+ const artifact = new URL(`../../scripts/binance-${kind === 'trading' ? 'trading' : 'coinmarketcap'}-data.user.js`, import.meta.url);
+ function setHidden(value) {
+ hidden = value;
+ window.document.dispatchEvent(new window.Event('visibilitychange'));
+ }
+ t.after(() => { setHidden(true); window.close(); });
+ return {
+ window, document: window.document, clock, network, errors, panelId,
+ panel: () => window.document.getElementById(panelId),
+ element: suffix => window.document.getElementById(`${panelId}-${suffix}`),
+ setHidden,
+ navigate: path => window.history.pushState({}, '', path),
+ async start({ waitForDocumentReady = true } = {}) {
+ // Wait for the real document readiness signal before installing the idle script.
+ if (waitForDocumentReady && window.document.readyState === 'loading') {
+ await new Promise(resolve => window.document.addEventListener('DOMContentLoaded', resolve, { once: true }));
+ }
+ new vm.Script(readFileSync(artifact, 'utf8'), { filename: fileURLToPath(artifact) }).runInContext(dom.getInternalVMContext());
+ },
+ rendered: predicate => observeDom(window, () => predicate(window.document.getElementById(panelId))),
+ };
+}
+
+export function tradingDataset(timestamp, {
+ oi = 2_000_000, previousOi = 1_000_000, supply = 10_000_000,
+ ratio = 1.5, basis = 0.01, funding = -0.0002,
+} = {}) {
+ return {
+ openInterestHist: Array.from({ length: 7 }, (_, index) => ({
+ timestamp, sumOpenInterest: String(index === 6 ? oi : previousOi),
+ sumOpenInterestValue: '100000000', CMCCirculatingSupply: String(supply),
+ })),
+ topLongShortAccountRatio: [{ timestamp, longShortRatio: String(ratio) }],
+ topLongShortPositionRatio: [{ timestamp, longShortRatio: String(ratio) }],
+ globalLongShortAccountRatio: [{ timestamp, longShortRatio: String(ratio) }],
+ takerlongshortRatio: [{ timestamp, buySellRatio: String(ratio) }],
+ basis: [{ timestamp, basisRate: String(basis) }],
+ fundingRate: [{ fundingRate: String(funding) }],
+ };
+}
+
+export async function completeTradingBatch(host, dataset, { symbol = 'BTCUSDT', status = {} } = {}) {
+ const pending = await host.network.waitForRequest(request => !request.settled && request.url.pathname.endsWith('/fundingRate') && request.url.searchParams.get('symbol') === symbol);
+ assert.equal(pending.kind, 'fetch');
+ const batch = host.network.requests.filter(request => !request.settled && (request.url.searchParams.get('symbol') || request.url.searchParams.get('pair')) === symbol);
+ assert.equal(batch.length, 7);
+ for (const request of batch) {
+ const key = request.url.pathname.split('/').at(-1);
+ request.respond(dataset[key], status[key] ?? 200);
+ }
+ return batch;
+}
+
+export async function activateTradingData(host, dataset = tradingDataset(Date.now()), options) {
+ const time = await host.network.waitForRequest(request => !request.settled && request.url.pathname.endsWith('/time'));
+ time.respond({ serverTime: Date.now() });
+ await completeTradingBatch(host, dataset, options);
+ await host.rendered(panel => panel?.querySelector('[data-role="updated-at"]')?.textContent.startsWith('更新于'));
+ await afterDataMediaResponseTurn();
+}
+
+export function cmcDetail(overrides = {}) {
+ return {
+ id: 1, name: 'Bitcoin', symbol: 'BTC', latestUpdateTime: '2026-09-16T00:00:00Z',
+ profileCompletionScore: { percentage: 85 },
+ statistics: {
+ price: 60_000, priceChangePercentage24h: 2.5, marketCap: 1_200_000_000_000,
+ marketCapChangePercentage24h: -1, ucm: 1_000_000_000, volume24h: 100_000_000,
+ turnover: 0.05, fullyDilutedMarketCap: 1_300_000_000_000,
+ fullyDilutedMarketCapChangePercentage24h: 0, liquidityMcapRatio: 0.03,
+ totalSupply: 21_000_000, maxSupply: 21_000_000, circulatingSupply: 20_000_000,
+ rank: 1,
+ },
+ ...overrides,
+ };
+}
+
+export async function completeCmcData(host, detail = cmcDetail(), { symbol = 'BTC', slug = 'bitcoin', holder = { showFlag: true, count: 10_000 }, map = true } = {}) {
+ if (map) {
+ const request = await host.network.waitForRequest(request => !request.settled && request.url.pathname.endsWith('/map') && request.url.searchParams.get('symbol') === symbol);
+ request.respond({ data: [{ id: detail.id, symbol, slug, is_active: 1 }] });
+ }
+ const request = await host.network.waitForRequest(request => !request.settled && request.url.pathname.endsWith('/detail') && request.url.searchParams.get('id') === String(detail.id));
+ request.respond({ data: detail });
+ if (!detail.showTreasuriesFlag) {
+ const holders = await host.network.waitForRequest(request => !request.settled && request.url.pathname.endsWith('/show_holders') && request.url.searchParams.get('cryptoId') === String(detail.id));
+ holders.respond({ data: holder });
+ }
+ await host.rendered(panel => panel?.querySelector('a')?.textContent === 'CMC data-api');
+}
diff --git a/test/helpers/data-media-migration-media-host.js b/test/helpers/data-media-migration-media-host.js
new file mode 100644
index 0000000..0e4e9c8
--- /dev/null
+++ b/test/helpers/data-media-migration-media-host.js
@@ -0,0 +1,144 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import vm from 'node:vm';
+import { JSDOM } from 'jsdom';
+import { afterDataMediaResponseTurn, installDataMediaClock } from './data-media-migration-host.js';
+
+/** Model browser HTTP completion without opening a network connection. */
+export function createMediaRequestBoundary() {
+ const requests = [];
+ class MediaXHR {
+ static UNSENT = 0;
+ static OPENED = 1;
+ static HEADERS_RECEIVED = 2;
+ static LOADING = 3;
+ static DONE = 4;
+ readyState = 0;
+ settled = false;
+ open(...args) {
+ this.args = args;
+ this.url = String(args[1]);
+ this.readyState = 1;
+ }
+ send(body) {
+ this.body = body;
+ requests.push(this);
+ }
+ receiveHeaders(status) {
+ assert.equal(this.readyState, 1, 'headers follow an opened request');
+ this.status = status;
+ this.readyState = 2;
+ if (this.onreadystatechange) this.onreadystatechange();
+ }
+ receiveChunk(response) {
+ assert.ok(this.readyState === 2 || this.readyState === 3, 'body chunks follow response headers');
+ this.response = response;
+ this.responseText = response;
+ this.readyState = 3;
+ if (this.onreadystatechange) this.onreadystatechange();
+ }
+ respond(response, status = 200) {
+ assert.equal(this.settled, false, 'an XHR completion is delivered only once');
+ this.settled = true;
+ this.status = status;
+ this.response = response;
+ this.responseText = response;
+ this.readyState = 4;
+ if (this.onreadystatechange) this.onreadystatechange();
+ if (this.onload) this.onload();
+ }
+ fail() {
+ assert.equal(this.settled, false);
+ this.settled = true;
+ this.onerror();
+ }
+ }
+ return { requests, MediaXHR };
+}
+
+export function createMediaHost(t, {
+ url = 'https://njav.com/watch/fixture', markup = 'Fixture lesson',
+ clipboard = 'native', storage = {}, now = Date.UTC(2026, 8, 16), parentUrl = null,
+} = {}) {
+ const dom = new JSDOM(parentUrl ? '' : markup, {
+ url: parentUrl || url, runScripts: 'outside-only', pretendToBeVisual: true,
+ });
+ let window = dom.window;
+ const parentMessages = [];
+ if (parentUrl) {
+ const frame = dom.window.document.createElement('iframe');
+ frame.src = url;
+ dom.window.document.body.append(frame);
+ window = frame.contentWindow;
+ window.document.open();
+ window.document.write(markup);
+ window.document.close();
+ dom.window.addEventListener('message', event => parentMessages.push(event.data));
+ }
+ const clock = installDataMediaClock(t, window, now);
+ const network = createMediaRequestBoundary();
+ const downloads = [], copied = [], fallbackCopies = [], alerts = [], opened = [], logs = [];
+ const blobs = new Map();
+ const revoked = [];
+ let nextBlob = 1;
+ window.XMLHttpRequest = network.MediaXHR;
+ window.Blob = Blob;
+ window.URL.createObjectURL = blob => {
+ const url = `blob:https://fixture.test/${nextBlob++}`;
+ blobs.set(url, blob);
+ return url;
+ };
+ window.URL.revokeObjectURL = url => { revoked.push(url); blobs.delete(url); };
+ window.alert = text => alerts.push(text);
+ window.open = url => opened.push(url);
+ window.console.log = (...args) => logs.push(args);
+ window.console.error = (...args) => logs.push(args);
+ if (clipboard !== 'absent') {
+ Object.defineProperty(window.navigator, 'clipboard', { value: {
+ writeText(text) {
+ if (clipboard === 'rejected') return Promise.reject(new Error('fixture clipboard permission denied'));
+ copied.push(text);
+ return Promise.resolve();
+ },
+ } });
+ }
+ window.document.execCommand = command => {
+ assert.equal(command, 'copy');
+ fallbackCopies.push(window.document.querySelector('textarea').value);
+ return true;
+ };
+ window.document.addEventListener('click', event => {
+ const anchor = event.target.closest('a[download]');
+ if (!anchor) return;
+ event.preventDefault();
+ downloads.push({ name: anchor.download, url: anchor.href, blob: blobs.get(anchor.href) });
+ }, true);
+ window.Element.prototype.getBoundingClientRect = function () {
+ const visible = this.matches('[data-visible="true"]');
+ return { left: 0, top: 0, right: visible ? 640 : 0, bottom: visible ? 360 : 0, width: visible ? 640 : 0, height: visible ? 360 : 0 };
+ };
+ for (const [key, value] of Object.entries(storage)) window.localStorage.setItem(key, value);
+ t.after(() => dom.window.close());
+ const artifact = new URL('../../scripts/m3u8-downloader.user.js', import.meta.url);
+ return {
+ window, document: window.document, clock, network, downloads, copied, fallbackCopies,
+ alerts, opened, logs, blobs, revoked, parentMessages,
+ element: id => window.document.getElementById(id),
+ async start({ waitForDocumentReady = true } = {}) {
+ if (waitForDocumentReady && window.document.readyState === 'loading') {
+ await new Promise(resolve => window.document.addEventListener('DOMContentLoaded', resolve, { once: true }));
+ }
+ const source = readFileSync(artifact, 'utf8');
+ if (parentUrl) window.eval(source);
+ else new vm.Script(source, { filename: fileURLToPath(artifact) }).runInContext(dom.getInternalVMContext());
+ clock.tick(0);
+ await afterDataMediaResponseTurn();
+ },
+ async renderFrame() {
+ await afterDataMediaResponseTurn();
+ clock.tick(16);
+ await afterDataMediaResponseTurn();
+ },
+ };
+}
diff --git a/test/helpers/native-precision-selection-host.js b/test/helpers/native-precision-selection-host.js
new file mode 100644
index 0000000..bc12fcf
--- /dev/null
+++ b/test/helpers/native-precision-selection-host.js
@@ -0,0 +1,37 @@
+/** Hold the native Select's click delivery while the real userscript observes its field. */
+export function installNativePrecisionSelectionHost({ ownerDocument = document } = {}) {
+ const requests = [];
+ let pending = null;
+ let releasing = false;
+ let disposed = false;
+ const capture = event => {
+ if (releasing) return;
+ const option = event.target.closest?.('.bn-select-bubble [data-precision-value]');
+ if (!option) return;
+ event.preventDefault();
+ event.stopImmediatePropagation();
+ pending = option;
+ requests.push({ value: option.dataset.precisionValue, at: ownerDocument.defaultView.Date.now() });
+ };
+ ownerDocument.addEventListener('click', capture, true);
+ return {
+ snapshot: () => requests.map(request => ({ ...request })),
+ commit() {
+ if (disposed || !pending?.isConnected) throw new Error('Native precision commit requires a connected pending option');
+ const option = pending;
+ pending = null;
+ releasing = true;
+ try {
+ option.click();
+ } finally {
+ releasing = false;
+ }
+ },
+ dispose() {
+ if (disposed) throw new Error('Native precision selection host was already disposed');
+ disposed = true;
+ pending = null;
+ ownerDocument.removeEventListener('click', capture, true);
+ },
+ };
+}
diff --git a/test/helpers/native-submit-feedback-host.js b/test/helpers/native-submit-feedback-host.js
new file mode 100644
index 0000000..a80d539
--- /dev/null
+++ b/test/helpers/native-submit-feedback-host.js
@@ -0,0 +1,71 @@
+/**
+ * Model a native form that performs client-side validation before issuing any
+ * exchange request. The real userscript still clicks the native button and
+ * observes its DOM feedback; this host owns only the page's validation boundary.
+ */
+export function installNativeSubmitFeedbackHost({ ownerDocument = document, initialText = '', busy = false } = {}) {
+ const entry = ownerDocument.querySelector('#trade-form .order-entry');
+ if (!entry || typeof initialText !== 'string' || typeof busy !== 'boolean') {
+ throw new Error('Native validation requires one order form and explicit feedback options');
+ }
+ const feedback = ownerDocument.createElement('div');
+ feedback.setAttribute('role', 'alert');
+ feedback.textContent = initialText;
+ ownerDocument.body.append(feedback);
+ const attempts = [];
+ let disposed = false;
+ const capture = event => {
+ const button = event.target.closest('button');
+ if (!button || !entry.contains(button)) return;
+ event.stopImmediatePropagation();
+ const price = entry.querySelector('input[id^="limitPrice-"]');
+ const quantity = entry.querySelector('input[id^="unitAmount-"]');
+ if (!price || !quantity) throw new Error('Native validation requires both submitted fields');
+ attempts.push({ action: button.textContent.trim(), price: price.value, quantity: quantity.value });
+ if (busy) button.setAttribute('data-loading', 'true');
+ };
+ entry.addEventListener('click', capture, true);
+ return {
+ snapshot() {
+ return { attempts: attempts.map(attempt => ({ ...attempt })), text: feedback.textContent };
+ },
+ publish(text, { replaceMarkup = false } = {}) {
+ if (disposed || attempts.length === 0 || typeof text !== 'string') {
+ throw new Error('Native validation needs an active submitted attempt before feedback');
+ }
+ if (replaceMarkup) {
+ const strong = ownerDocument.createElement('strong');
+ strong.textContent = text;
+ feedback.replaceChildren(strong);
+ } else {
+ feedback.textContent = text;
+ }
+ },
+ dispose() {
+ if (disposed) throw new Error('Native validation was already disposed');
+ disposed = true;
+ entry.removeEventListener('click', capture, true);
+ entry.querySelectorAll('button[data-loading="true"]').forEach(button => button.removeAttribute('data-loading'));
+ feedback.remove();
+ },
+ };
+}
+
+/** Model a controlled native input rejecting each proposed value at its input boundary. */
+export function installNativeInputRollbackHost({ ownerDocument = document, selector, rollbackValue }) {
+ const inputs = ownerDocument.querySelectorAll(selector);
+ if (inputs.length !== 1 || typeof rollbackValue !== 'string') {
+ throw new Error('Native input rollback requires one field and its explicit committed value');
+ }
+ const input = inputs[0];
+ const proposed = [];
+ const reject = () => {
+ proposed.push(input.value);
+ input.value = rollbackValue;
+ };
+ input.addEventListener('input', reject);
+ return {
+ snapshot: () => ({ proposed: [...proposed], current: input.value }),
+ dispose: () => input.removeEventListener('input', reject),
+ };
+}
diff --git a/test/helpers/order-entry-host-boundaries.js b/test/helpers/order-entry-host-boundaries.js
new file mode 100644
index 0000000..7a6b0eb
--- /dev/null
+++ b/test/helpers/order-entry-host-boundaries.js
@@ -0,0 +1,196 @@
+/** Model the native order-type tab's request and later committed selection separately. */
+export function installNativePostOnlyTransition({ ownerDocument = document } = {}) {
+ const root = ownerDocument.querySelector('.order-type-tabs');
+ const postOnly = root?.querySelector('[role="tab"][data-tab-key="POST_ONLY"]');
+ if (!root || !postOnly || root.querySelectorAll('[role="tab"]').length !== 1) {
+ throw new Error('The native order-type boundary requires one existing Post Only tab');
+ }
+ const originalSelection = postOnly.getAttribute('aria-selected');
+ const limit = ownerDocument.createElement('div');
+ limit.setAttribute('role', 'tab');
+ limit.setAttribute('data-tab-key', 'LIMIT');
+ limit.setAttribute('aria-selected', 'true');
+ limit.textContent = '限价';
+ root.prepend(limit);
+ postOnly.setAttribute('aria-selected', 'false');
+ let requests = 0;
+ let committed = false;
+ let disposed = false;
+ const request = () => { requests += 1; };
+ postOnly.addEventListener('click', request);
+ return {
+ snapshot() {
+ return {
+ requests,
+ committed,
+ selected: Array.from(root.querySelectorAll('[role="tab"][aria-selected="true"]'))
+ .map(tab => tab.getAttribute('data-tab-key')),
+ };
+ },
+ commit() {
+ if (disposed || committed || requests === 0) {
+ throw new Error('A native Post Only request must be pending before commit');
+ }
+ committed = true;
+ limit.setAttribute('aria-selected', 'false');
+ postOnly.setAttribute('aria-selected', 'true');
+ },
+ dispose() {
+ if (disposed) throw new Error('The native Post Only boundary is already disposed');
+ disposed = true;
+ postOnly.removeEventListener('click', request);
+ postOnly.setAttribute('aria-selected', originalSelection);
+ limit.remove();
+ },
+ };
+}
+
+/**
+ * Model the native form's mode commit before its separate quantity publication.
+ * This boundary owns only the native DOM transition, not account or order APIs.
+ */
+export function installNativeCloseQuantityTransition({ ownerDocument = document } = {}) {
+ const root = ownerDocument.querySelector('#trade-form');
+ const openTab = root?.querySelector('[data-trade-mode="OPEN"]');
+ const closeTab = root?.querySelector('[data-trade-mode="CLOSE"]');
+ const entry = root?.querySelector('.order-entry');
+ const price = entry?.querySelector('input[id^="limitPrice-"]');
+ const quantity = entry?.querySelector('input[id^="unitAmount-"]');
+ const buttons = Array.from(entry?.querySelectorAll('button') || []);
+ if (!root || !openTab || !closeTab || !entry || !price || !quantity || buttons.length !== 2
+ || openTab.getAttribute('aria-selected') !== 'true') {
+ throw new Error('The native close transition requires one complete open form');
+ }
+ entry.querySelectorAll('[data-testid="max-sell-amount"], [data-testid="max-buy-amount"]')
+ .forEach(node => node.remove());
+ let phase = 'open';
+ let requests = 0;
+ let disposed = false;
+ const request = event => {
+ event.stopImmediatePropagation();
+ if (phase !== 'open') throw new Error('The native close transition has already started');
+ requests += 1;
+ phase = 'quantity-pending';
+ openTab.setAttribute('aria-selected', 'false');
+ closeTab.setAttribute('aria-selected', 'true');
+ price.id = 'limitPrice-close';
+ quantity.id = 'unitAmount-close';
+ buttons[0].textContent = '平多';
+ buttons[1].textContent = '平空';
+ buttons.forEach(button => { button.disabled = true; });
+ };
+ // The document's userscript listener still receives the real click first.
+ closeTab.addEventListener('click', request, true);
+ return {
+ snapshot() {
+ return {
+ phase,
+ requests,
+ selectedMode: root.querySelector('[data-trade-mode][aria-selected="true"]')?.getAttribute('data-trade-mode'),
+ quantities: Array.from(entry.querySelectorAll('[data-testid^="max-"]')).map(node => node.textContent),
+ buttons: buttons.map(button => ({ text: button.textContent, disabled: button.disabled })),
+ };
+ },
+ publish({ longQty, shortQty }) {
+ if (disposed || phase !== 'quantity-pending') throw new Error('Native close quantities are not pending');
+ if (![longQty, shortQty].every(value => typeof value === 'string' && /^(?:0|[1-9]\d*)(?:\.\d+)?$/.test(value))) {
+ throw new Error('Native close quantities must be explicit non-negative decimal strings');
+ }
+ for (const [testId, value] of [['max-sell-amount', longQty], ['max-buy-amount', shortQty]]) {
+ const node = ownerDocument.createElement('div');
+ node.setAttribute('data-testid', testId);
+ node.textContent = `可平 ${value} HYPE`;
+ entry.append(node);
+ }
+ buttons[0].disabled = Number(longQty) === 0;
+ buttons[1].disabled = Number(shortQty) === 0;
+ phase = 'complete';
+ },
+ dispose() {
+ if (disposed) throw new Error('The native close boundary is already disposed');
+ disposed = true;
+ closeTab.removeEventListener('click', request, true);
+ },
+ };
+}
+
+/** Count actual DOM work while forwarding native results, exceptions, and receivers unchanged. */
+export function installOrderEntryReadProbe({ ownerDocument = document } = {}) {
+ const view = ownerDocument.defaultView;
+ const orderbook = ownerDocument.querySelector('#futuresOrderbook');
+ const panel = ownerDocument.querySelector('#jh-binance-close-qty-multiplier-panel');
+ const spacer = ownerDocument.querySelector('#jh-binance-close-qty-multiplier-spacer');
+ if (!view || !orderbook || !panel || !spacer) throw new Error('Read instrumentation requires the native book and mounted panel');
+ const counts = {
+ queryCalls: 0,
+ orderbookScans: 0,
+ layoutReads: 0,
+ orderbookLayoutReads: 0,
+ spacerRectReads: 0,
+ panelHeightReads: 0,
+ panelMutations: 0,
+ };
+ const replacements = [];
+ let disposed = false;
+ const inOrderbook = node => node === orderbook || orderbook.contains(node);
+ const replaceMethod = (owner, key, observe) => {
+ const descriptor = Object.getOwnPropertyDescriptor(owner, key);
+ if (typeof descriptor?.value !== 'function') throw new Error(`Native method ${key} is unavailable`);
+ const replacement = function (...args) {
+ const result = Reflect.apply(descriptor.value, this, args);
+ observe(this, result);
+ return result;
+ };
+ Object.defineProperty(owner, key, { ...descriptor, value: replacement });
+ replacements.push({ owner, key, descriptor, replacement, kind: 'value' });
+ };
+ const observeQuery = (root, nodes) => {
+ counts.queryCalls += 1;
+ if (inOrderbook(root) || Array.from(nodes).some(inOrderbook)) counts.orderbookScans += 1;
+ };
+ for (const owner of [view.Document.prototype, view.Element.prototype]) {
+ replaceMethod(owner, 'querySelectorAll', observeQuery);
+ }
+ for (const key of ['getBoundingClientRect', 'getClientRects']) {
+ replaceMethod(view.Element.prototype, key, element => {
+ counts.layoutReads += 1;
+ if (inOrderbook(element)) counts.orderbookLayoutReads += 1;
+ if (element === spacer && key === 'getBoundingClientRect') counts.spacerRectReads += 1;
+ });
+ }
+ for (const key of ['offsetWidth', 'offsetHeight']) {
+ const owner = view.HTMLElement.prototype;
+ const descriptor = Object.getOwnPropertyDescriptor(owner, key);
+ if (typeof descriptor?.get !== 'function') throw new Error(`Native property ${key} is unavailable`);
+ const replacement = function () {
+ const result = Reflect.apply(descriptor.get, this, []);
+ counts.layoutReads += 1;
+ if (inOrderbook(this)) counts.orderbookLayoutReads += 1;
+ if (this === panel && key === 'offsetHeight') counts.panelHeightReads += 1;
+ return result;
+ };
+ Object.defineProperty(owner, key, { ...descriptor, get: replacement });
+ replacements.push({ owner, key, descriptor, replacement, kind: 'get' });
+ }
+ const observer = new view.MutationObserver(records => { counts.panelMutations += records.length; });
+ observer.observe(panel, { attributes: true, childList: true, characterData: true, subtree: true });
+ return {
+ snapshot() {
+ counts.panelMutations += observer.takeRecords().length;
+ return { ...counts };
+ },
+ dispose() {
+ if (disposed) throw new Error('Read instrumentation is already disposed');
+ disposed = true;
+ counts.panelMutations += observer.takeRecords().length;
+ observer.disconnect();
+ for (const { owner, key, descriptor, replacement, kind } of replacements.reverse()) {
+ if (Object.getOwnPropertyDescriptor(owner, key)[kind] !== replacement) {
+ throw new Error(`Native ${key} changed while read instrumentation was active`);
+ }
+ Object.defineProperty(owner, key, descriptor);
+ }
+ return { ...counts };
+ },
+ };
+}
diff --git a/test/helpers/orderbook-migration-errors.js b/test/helpers/orderbook-migration-errors.js
new file mode 100644
index 0000000..ccb60d2
--- /dev/null
+++ b/test/helpers/orderbook-migration-errors.js
@@ -0,0 +1,9 @@
+/** Records the real operation's failure so execution and error assertions stay separate. */
+export function captureThrownError(operation) {
+ try {
+ operation();
+ return null;
+ } catch (error) {
+ return error;
+ }
+}
diff --git a/test/helpers/orderbook-migration-frames.js b/test/helpers/orderbook-migration-frames.js
new file mode 100644
index 0000000..eab0bd9
--- /dev/null
+++ b/test/helpers/orderbook-migration-frames.js
@@ -0,0 +1,29 @@
+/**
+ * Supplies browser frame scheduling for an isolated JSDOM document. Callbacks
+ * scheduled during a frame are deferred until the next explicit frame.
+ */
+export function createAnimationFrameBoundary(view) {
+ const callbacks = new Map();
+ let nextHandle = 1;
+ view.requestAnimationFrame = (callback) => {
+ const handle = nextHandle;
+ nextHandle += 1;
+ callbacks.set(handle, callback);
+ return handle;
+ };
+ view.cancelAnimationFrame = (handle) => callbacks.delete(handle);
+ return {
+ get pendingCount() {
+ return callbacks.size;
+ },
+ runFrame(timestamp) {
+ const handles = [...callbacks.keys()];
+ for (const handle of handles) {
+ if (!callbacks.has(handle)) continue;
+ const callback = callbacks.get(handle);
+ callbacks.delete(handle);
+ callback(timestamp);
+ }
+ },
+ };
+}
diff --git a/test/helpers/orderbook-migration-ladder-options.js b/test/helpers/orderbook-migration-ladder-options.js
new file mode 100644
index 0000000..d0e01f9
--- /dev/null
+++ b/test/helpers/orderbook-migration-ladder-options.js
@@ -0,0 +1,98 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import vm from 'node:vm';
+import { parse } from 'espree';
+import { JSDOM } from 'jsdom';
+
+import {
+ loadModeSymbolPrecisionNumberOption,
+ migrateModeSymbolPrecisionNumberOption,
+ saveModeSymbolPrecisionNumberOption,
+} from '../../src/binance-orderbook-trade/core/panel-options.js';
+import { shouldDisableCloseControl } from '../../src/binance-orderbook-trade/core/close-action.js';
+import { normalizeDecimalString } from '../../src/binance-orderbook-trade/core/decimal.js';
+import { parseTradeModeLabel } from '../../src/binance-orderbook-trade/dom/trade-form.js';
+import { parseFuturesTradingSymbolFromPathname } from '../../src/shared/binance-futures-route.js';
+import {
+ PANEL_COPY, combineLocalizedText, formatLocalizedText, localizedText,
+} from '../../src/binance-orderbook-trade/contracts/panel-copy.js';
+
+const source = readFileSync(new URL('../../src/binance-orderbook-trade/index.user.js', import.meta.url), 'utf8');
+const program = parse(source, { ecmaVersion: 'latest', sourceType: 'module', range: true });
+const runtime = program.body.find((node) => node.type === 'ExpressionStatement'
+ && node.expression.type === 'CallExpression'
+ && node.expression.callee.type === 'FunctionExpression').expression.callee.body.body;
+
+const constants = new Set([
+ 'LOCAL_LADDER_OPEN_PERCENT_KEY', 'LOCAL_LADDER_CLOSE_PERCENT_KEY',
+ 'LOCAL_LADDER_OPEN_LEVELS_KEY', 'LOCAL_LADDER_CLOSE_LEVELS_KEY',
+ 'LOCAL_LADDER_OPEN_STEP_KEY', 'LOCAL_LADDER_CLOSE_STEP_KEY',
+ 'DEFAULT_LADDER_OPEN_PERCENT', 'DEFAULT_LADDER_CLOSE_PERCENT',
+ 'DEFAULT_LADDER_LEVELS', 'DEFAULT_LADDER_STEP',
+ 'LADDER_OPEN_PERCENTS', 'LADDER_CLOSE_PERCENTS', 'LADDER_LEVEL_OPTIONS',
+ 'LADDER_STEP_MIN', 'LADDER_STEP_MAX', 'LADDER_STEP_OPTIONS',
+ 'LADDER_PERCENT_STORAGE_KEYS', 'LADDER_LEVELS_STORAGE_KEYS', 'LADDER_STEP_STORAGE_KEYS',
+ 'PRIMARY_EMPHASIS_COLOR', 'PRIMARY_EMPHASIS_FONT_WEIGHT', 'CONTROL_BORDER_COLOR',
+ 'CONTROL_BACKGROUND_COLOR', 'CONTROL_TEXT_COLOR', 'CONTROL_FONT_WEIGHT',
+ 'MUTED_TEXT_COLOR', 'NEUTRAL_CONTROL_STYLE',
+ 'LADDER_CONTROL_BUTTON_HEIGHT', 'LADDER_CONTROL_BUTTON_FONT_SIZE',
+]);
+const functions = new Set([
+ 'getCurrentSymbol', 'getActiveTradeMode', 'isOrderbookPrecisionNumericText',
+ 'findOrderbookPrecisionTrigger', 'readCurrentOrderbookPrecisionValue',
+ 'getLadderOpenPercent', 'setLadderOpenPercent', 'getLadderClosePercent', 'setLadderClosePercent',
+ 'getLadderLevels', 'setLadderLevels', 'getLadderStep', 'setLadderStep',
+ 'readLadderOptionContext', 'areLadderOptionContextsEqual', 'hasLadderOptionContextChanged',
+ 'getPanelOptionContext', 'ui', 'ladderOptionButton', 'ladderOptionRow',
+ 'ladderActionButton', 'ladderExecutionButton', 'getLadderControlSections',
+ 'localizedActionStatus', 'formatLadderPlanDetail', 'formatLadderPlanStatus',
+]);
+const declarations = runtime.filter((node) => (
+ (node.type === 'VariableDeclaration' && node.declarations.some((entry) => constants.has(entry.id.name)))
+ || (node.type === 'FunctionDeclaration' && functions.has(node.id.name))
+));
+assert.equal(declarations.length, constants.size + functions.size);
+const fixtureSource = declarations.map((node) => source.slice(...node.range)).join('\n');
+
+/** Executes original preference and rendering functions against real DOM and Storage boundaries. */
+export function createLadderOptionHarness() {
+ const dom = new JSDOM(`
+
Open
+
0.01
+ `, { url: 'https://fixture.example/en/futures/BTCUSDT' });
+ const scheduledRenders = [];
+ const context = vm.createContext({
+ document: dom.window.document,
+ location: dom.window.location,
+ localStorage: dom.window.localStorage,
+ loadModeSymbolPrecisionNumberOption,
+ migrateModeSymbolPrecisionNumberOption,
+ saveModeSymbolPrecisionNumberOption,
+ shouldDisableCloseControl,
+ normalizeDecimalString,
+ parseTradeModeLabel,
+ parseFuturesTradingSymbolFromPathname,
+ PANEL_COPY, combineLocalizedText, formatLocalizedText, localizedText,
+ activeUiLocale: 'en',
+ ladderTask: null,
+ continuousLadderTask: null,
+ singleOrderTask: null,
+ cancelCurrentSymbolOpenOrdersBlocksLadderActions: false,
+ activeLadderActionType: null,
+ activeContinuousLadderActionType: null,
+ scheduleRenderPanel() { scheduledRenders.push('render'); },
+ });
+ vm.runInContext(fixtureSource, context, { filename: 'orderbook-ladder-options-fixture.js' });
+ return {
+ context,
+ document: dom.window.document,
+ storage: dom.window.localStorage,
+ scheduledRenders,
+ setNativeContext({ symbol, mode, precision }) {
+ dom.reconfigure({ url: `https://fixture.example/en/futures/${symbol}` });
+ dom.window.document.querySelector('[role="tab"]').textContent = mode;
+ dom.window.document.querySelector('.tick-content').textContent = precision;
+ },
+ close() { dom.window.close(); },
+ };
+}
diff --git a/test/helpers/strategy-migration-boundaries.js b/test/helpers/strategy-migration-boundaries.js
new file mode 100644
index 0000000..72893cf
--- /dev/null
+++ b/test/helpers/strategy-migration-boundaries.js
@@ -0,0 +1,147 @@
+import assert from 'node:assert/strict';
+
+/** Observe native JSDOM intervals while Node owns the actual scheduling clock. */
+export function installStrategyClock(t, view, now = 7000) {
+ t.mock.timers.enable({ apis: ['Date', 'setTimeout', 'setInterval'], now });
+ const setInterval = view.setInterval;
+ const clearInterval = view.clearInterval;
+ const intervals = new Map();
+ view.setInterval = function schedule(callback, milliseconds, ...args) {
+ const id = Reflect.apply(setInterval, this, [callback, milliseconds, ...args]);
+ intervals.set(id, { milliseconds });
+ return id;
+ };
+ view.clearInterval = function cancel(id) {
+ Reflect.apply(clearInterval, this, [id]);
+ intervals.delete(id);
+ };
+ return {
+ intervals,
+ advance: milliseconds => t.mock.timers.tick(milliseconds),
+ setTime: milliseconds => t.mock.timers.setTime(milliseconds),
+ };
+}
+
+/** Count real selector queries without changing native selection or errors. */
+export function observeStrategyQueries(document) {
+ const ownDescriptor = Object.getOwnPropertyDescriptor(document, 'querySelectorAll');
+ const query = document.querySelectorAll;
+ const counts = new Map();
+ document.querySelectorAll = function querySelectorAll(selector) {
+ counts.set(selector, (counts.get(selector) || 0) + 1);
+ return Reflect.apply(query, this, [selector]);
+ };
+ return {
+ count: selector => counts.get(selector) || 0,
+ reset: () => counts.clear(),
+ restore() {
+ if (ownDescriptor) Object.defineProperty(document, 'querySelectorAll', ownDescriptor);
+ else delete document.querySelectorAll;
+ },
+ };
+}
+
+/** The sandbox cancels each prompt; any page-realm prompt is an explicit failure. */
+export function createStrategyPromptBoundary() {
+ const messages = [];
+ const pageAttempts = [];
+ return {
+ messages,
+ pageAttempts,
+ sandboxPrompt(message) { messages.push(message); return null; },
+ pagePrompt(...args) {
+ pageAttempts.push(args);
+ throw new Error('Page prompt must not receive private input');
+ },
+ };
+}
+
+/** Hold one real digest result; algorithm/input validation remains WebCrypto's. */
+export function createStrategyDigestGate(subtle, pauseAt) {
+ assert.equal(Number.isInteger(pauseAt) && pauseAt > 0, true);
+ const entered = Promise.withResolvers();
+ const release = Promise.withResolvers();
+ const calls = [];
+ return {
+ calls,
+ entered: entered.promise,
+ release: () => release.resolve(),
+ subtle: {
+ async digest(...args) {
+ const ordinal = calls.push(args);
+ const result = await Reflect.apply(subtle.digest, subtle, args);
+ if (ordinal === pauseAt) {
+ entered.resolve();
+ await release.promise;
+ }
+ return result;
+ },
+ },
+ };
+}
+
+/** Observe completion across host jobs; elapsed time bounds failure only. */
+export async function observeStrategyCondition(predicate, description) {
+ const deadline = performance.now() + 2000;
+ while (!predicate()) {
+ if (performance.now() > deadline) throw new Error(`Strategy completion deadline exceeded: ${description}`);
+ await new Promise(setImmediate);
+ }
+}
+
+/** Execute a rejecting contract once so its actual error can be asserted in Then. */
+export function captureStrategyError(operation) {
+ try {
+ operation();
+ } catch (error) {
+ return error;
+ }
+ throw new Error('Expected the strategy operation to reject its input');
+}
+
+/** Tampermonkey request boundary exposes host callbacks without settling them for the caller. */
+export function createStrategyGmBoundary() {
+ const requests = [];
+ return {
+ requests,
+ request(options) {
+ const record = {
+ options,
+ abortCalls: 0,
+ load: response => options.onload(response),
+ error: () => options.onerror(),
+ timeout: () => options.ontimeout(),
+ abort() { record.abortCalls += 1; options.onabort(); },
+ };
+ requests.push(record);
+ return { abort: () => record.abort() };
+ },
+ };
+}
+
+/** Expose raw native shape outputs, including malformed values, without repairing them. */
+export function createStrategyShapeBoundary({
+ shapeId = 'native-shape',
+ points = [{ time: 10, price: 1.25 }],
+ listedShapes = [{ id: shapeId }],
+} = {}) {
+ const created = [];
+ const removed = [];
+ const shape = { getPoints: () => points };
+ return {
+ created,
+ removed,
+ chart: {
+ async createShape(point, options) {
+ created.push({ point, options });
+ return shapeId;
+ },
+ getShapeById(id) {
+ assert.equal(id, shapeId);
+ return shape;
+ },
+ getAllShapes: () => listedShapes,
+ removeEntity: id => removed.push(id),
+ },
+ };
+}
diff --git a/test/helpers/strategy29-runtime-boundary-host.js b/test/helpers/strategy29-runtime-boundary-host.js
new file mode 100644
index 0000000..3480f2e
--- /dev/null
+++ b/test/helpers/strategy29-runtime-boundary-host.js
@@ -0,0 +1,202 @@
+import assert from 'node:assert/strict';
+import { loadFixtureDom } from './dom.js';
+
+/** Positive OHLC candles provide both trend directions without supplying detector decisions. */
+export function createOscillatingStrategyBars(count = 165) {
+ return Array.from({ length: count }, (_, index) => {
+ const close = 100 + 6 * Math.sin(index / 11) + 0.7 * Math.cos(index / 3);
+ return { time: (index + 1) * 60, open: close + 0.2, high: close + 1.8, low: close - 1.9, close };
+ });
+}
+
+export function exportStrategyBars(bars) {
+ return {
+ schema: ['time', 'open', 'high', 'low', 'close'].map(type => ({ type })),
+ data: bars.map(bar => ({ 0: bar.time, 1: bar.open, 2: bar.high, 3: bar.low, 4: bar.close })),
+ };
+}
+
+function createNativeSubscription() {
+ const listeners = new Map();
+ return {
+ subscribe(owner, callback) { listeners.set(callback, owner); },
+ unsubscribe(owner, callback) {
+ assert.equal(listeners.get(callback), owner);
+ listeners.delete(callback);
+ },
+ emit() { for (const callback of [...listeners.keys()]) callback(); },
+ get size() { return listeners.size; },
+ };
+}
+
+/** Model native chart I/O and ownership only; no detector, monitor, or marker-layer method is replaced. */
+export function createStrategy29ChartHost({ bars = createOscillatingStrategyBars(), resolution = '1', omittedMethods = [] } = {}) {
+ const dom = loadFixtureDom('');
+ const view = dom.window;
+ const document = view.document;
+ Object.defineProperty(document, 'hidden', { configurable: true, value: false });
+ const root = document.querySelector('.chart-widget-root');
+ const intervalChanged = createNativeSubscription();
+ const dataLoaded = createNativeSubscription();
+ const shapes = new Map();
+ const created = [];
+ const removed = [];
+ const propertyWrites = [];
+ const exports = [];
+ const exportQueue = [];
+ const creationQueue = [];
+ const shapeListQueue = [];
+ const pointReadActions = [];
+ const propertyOverrides = new Map();
+ let currentBars = bars;
+ let currentResolution = resolution;
+ let symbol = 'BTRUSDT@PRICETYPE=LAST';
+ let modelReady = true;
+ let dataReady = true;
+ let ignorePropertyWrites = false;
+ let nativeIntervalSubscription = intervalChanged;
+ let nextId = 1;
+
+ const chart = {
+ hasModel: () => modelReady,
+ dataReady: () => dataReady,
+ resolution() { assert.equal(modelReady, true); return currentResolution; },
+ symbol: () => symbol,
+ onIntervalChanged: () => nativeIntervalSubscription,
+ onDataLoaded: () => dataLoaded,
+ async exportData(options) {
+ exports.push(structuredClone(options));
+ const next = exportQueue.shift();
+ if (next) return next();
+ return exportStrategyBars(currentBars);
+ },
+ async createShape(point, options) {
+ created.push({ point: structuredClone(point), options: structuredClone(options) });
+ const next = creationQueue.shift();
+ if (next) {
+ const result = await next();
+ if (result.kind === 'id') return result.value;
+ }
+ const id = 'native-' + nextId++;
+ const record = {
+ point: structuredClone(point), options: structuredClone(options),
+ properties: { ...structuredClone(options.overrides), icon: options.icon },
+ getPoints() {
+ const result = [structuredClone(record.point)];
+ pointReadActions.shift()?.();
+ return result;
+ },
+ getProperties() {
+ return propertyOverrides.has(id) ? propertyOverrides.get(id) : structuredClone(record.properties);
+ },
+ setProperties(properties, saveDefaults) {
+ propertyWrites.push({ id, properties: structuredClone(properties), saveDefaults });
+ if (!ignorePropertyWrites) Object.assign(record.properties, structuredClone(properties));
+ },
+ };
+ shapes.set(id, record);
+ return id;
+ },
+ getShapeById: id => shapes.get(id),
+ getAllShapes: () => shapeListQueue.length > 0
+ ? shapeListQueue.shift()
+ : [...shapes].map(([id, record]) => ({ id, name: record.options.shape })),
+ removeEntity(id) {
+ assert.equal(shapes.has(id), true, 'Native removal requires an existing entity');
+ removed.push(id);
+ shapes.delete(id);
+ },
+ };
+ for (const method of omittedMethods) {
+ assert.equal(typeof chart[method], 'function', 'Only a declared native chart capability can be omitted');
+ delete chart[method];
+ }
+ let activeChart = chart;
+ const tradingViewApi = {
+ activeChart: () => activeChart,
+ saveChart(callback) {
+ callback({ drawings: [...shapes].filter(([, record]) => !record.options.disableSave).map(([id]) => ({ id })) });
+ },
+ };
+ document.querySelector('iframe').contentWindow.tradingViewApi = tradingViewApi;
+ return {
+ dom, view, document, root, chart, tradingViewApi,
+ created, removed, propertyWrites, exports, shapes, intervalChanged, dataLoaded,
+ setBars(value) { currentBars = value; },
+ setSymbol(value) { symbol = value; },
+ setActiveChart(value) { activeChart = value; },
+ setModelReady(value) { modelReady = value; },
+ setDataReady(value) { dataReady = value; },
+ setIntervalSubscription(value) { nativeIntervalSubscription = value; },
+ listShapesNext(value) { shapeListQueue.push(value); },
+ setHidden(value) { Object.defineProperty(document, 'hidden', { configurable: true, value }); },
+ changeInterval(value) { currentResolution = value; dataReady = false; intervalChanged.emit(); },
+ finishData() { dataReady = true; dataLoaded.emit(); },
+ ignorePropertyWrites(value) { ignorePropertyWrites = value; },
+ setNativeProperties(id, value) { assert.equal(shapes.has(id), true); propertyOverrides.set(id, value); },
+ editProperties(id, properties) { Object.assign(shapes.get(id).properties, properties); },
+ onNextPointRead(action) { pointReadActions.push(action); },
+ failNextExport(reason) { exportQueue.push(() => Promise.reject(reason)); },
+ exportNext(value) { exportQueue.push(() => Promise.resolve(value)); },
+ holdNextExport() {
+ const entered = Promise.withResolvers();
+ const response = Promise.withResolvers();
+ exportQueue.push(() => { entered.resolve(); return response.promise; });
+ return { entered: entered.promise, resolve: value => response.resolve(value), reject: reason => response.reject(reason) };
+ },
+ holdNextCreation() {
+ const entered = Promise.withResolvers();
+ const response = Promise.withResolvers();
+ creationQueue.push(() => { entered.resolve(); return response.promise; });
+ return { entered: entered.promise, release: () => response.resolve({ kind: 'created' }) };
+ },
+ returnNextCreationId(value) { creationQueue.push(() => Promise.resolve({ kind: 'id', value })); },
+ addForeignShape(id) { shapes.set(id, { options: { shape: 'trend_line', disableSave: false } }); },
+ close() { dom.window.close(); },
+ };
+}
+
+/** FIFO gateway transport preserves declared responses and cancellation ownership without business validation. */
+export function createStrategy29RequestHost() {
+ const queue = [];
+ const requests = [];
+ return {
+ requests,
+ respond(body, status = 200) { queue.push(() => ({ status, responseText: JSON.stringify(body) })); },
+ respondRaw(value) { queue.push(() => value); },
+ reject(error) { queue.push(() => Promise.reject(error)); },
+ hold() {
+ const entered = Promise.withResolvers();
+ const result = Promise.withResolvers();
+ queue.push(() => { entered.resolve(); return result.promise; });
+ return { entered: entered.promise, respond: (body, status = 200) => result.resolve({ status, responseText: JSON.stringify(body) }) };
+ },
+ async request(options) {
+ requests.push(options);
+ const next = queue.shift();
+ assert.equal(typeof next, 'function', 'Every gateway request requires a declared response');
+ return next();
+ },
+ get remaining() { return queue.length; },
+ };
+}
+
+/** Expose a separate installed provider's public protocol without interpreting or repairing its payloads. */
+export function createStrategyGatewayProviderHost(view) {
+ const slot = Symbol.for('jh-userscripts.signal-gateway');
+ assert.equal(view[slot], undefined, 'The provider boundary requires an unclaimed public bridge slot');
+ const transport = createStrategy29RequestHost();
+ let version = 1;
+ let state = { available: true, configured: true, settingsRevision: 1 };
+ const bridge = {
+ get version() { return version; },
+ getState: () => state,
+ request: (path, signal) => transport.request({ path, signal }),
+ };
+ Object.defineProperty(view, slot, { configurable: true, value: bridge });
+ return {
+ bridge, transport,
+ setVersion(value) { version = value; },
+ setState(value) { state = value; },
+ };
+}
diff --git a/test/unit/account-rebalance-api-contract.test.js b/test/unit/account-rebalance-api-contract.test.js
new file mode 100644
index 0000000..60abe75
--- /dev/null
+++ b/test/unit/account-rebalance-api-contract.test.js
@@ -0,0 +1,67 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { ACCOUNT_PATHS, createAccountRebalanceApi } from '../../e2e/binance-orderbook/fixtures/account-rebalance-api.js';
+
+test('user can detect a wrong transfer direction because the native account fake applies the actual request', () => {
+ // Given balances are held by an independently modeled external account boundary.
+ const api = createAccountRebalanceApi({ FUNDING: '50.12345678', MAIN: '40', UMFUTURE: '10' });
+
+ // When a caller moves funds in a direction that does not follow the intended target ratio.
+ const response = api.handle({ pathname: ACCOUNT_PATHS.transfer, method: 'POST',
+ body: { asset: 'USDT', amount: '0.12345678', kindType: 'CARD_FUTURE' } });
+
+ // Then the wrong request remains observable, exact balances change accordingly, and no plan is repaired.
+ assert.deepEqual(response, { status: 200, body: { success: true } });
+ assert.deepEqual(api.snapshot().balances, { FUNDING: '50', MAIN: '40', UMFUTURE: '10.12345678' });
+ assert.deepEqual(api.snapshot().requests[0].body, { asset: 'USDT', amount: '0.12345678', kindType: 'CARD_FUTURE' });
+});
+
+test('user can hold an acknowledged transfer until its balance update is explicitly committed', () => {
+ // Given native acknowledgement and the later balance publication are separate events.
+ const api = createAccountRebalanceApi({ FUNDING: '100', MAIN: '0', UMFUTURE: '0' }, { commitTransfers: false });
+
+ // When a transfer is acknowledged before its balance publication.
+ api.handle({ pathname: ACCOUNT_PATHS.transfer, method: 'POST', body: { asset: 'USDT', amount: '40', kindType: 'CARD_MAIN' } });
+
+ // Then the old balances and exactly one pending transfer remain visible.
+ assert.deepEqual(api.snapshot().balances, { FUNDING: '100', MAIN: '0', UMFUTURE: '0' });
+ assert.equal(api.snapshot().pendingTransfers, 1);
+
+ // When the native account publishes the completed transfer.
+ api.commitPendingTransfers();
+
+ // Then the amount moves once and the pending queue becomes empty.
+ assert.deepEqual(api.snapshot().balances, { FUNDING: '60', MAIN: '40', UMFUTURE: '0' });
+ assert.equal(api.snapshot().pendingTransfers, 0);
+});
+
+test('user receives a declared HTTP rejection without an invented transfer or balance change', () => {
+ // Given the next transfer response is a declared upstream rejection.
+ const api = createAccountRebalanceApi({ FUNDING: '100', MAIN: '0', UMFUTURE: '0' });
+ api.failNext(ACCOUNT_PATHS.transfer, { status: 403, body: { success: false, message: 'Fixture rejection' } });
+
+ // When a valid transfer request reaches that external boundary.
+ const response = api.handle({ pathname: ACCOUNT_PATHS.transfer, method: 'POST', body: { asset: 'USDT', amount: '40', kindType: 'CARD_MAIN' } });
+
+ // Then the original rejection and balances remain authoritative.
+ assert.deepEqual(response, { status: 403, body: { success: false, message: 'Fixture rejection' } });
+ assert.deepEqual(api.snapshot().balances, { FUNDING: '100', MAIN: '0', UMFUTURE: '0' });
+ assert.equal(api.snapshot().requests.length, 1);
+});
+
+test('user receives wallet and position payloads from the declared external account state', () => {
+ // Given every wallet and a current position are explicitly configured.
+ const api = createAccountRebalanceApi({ FUNDING: '50', MAIN: '40', UMFUTURE: '10' });
+ api.setPositions([{ symbol: 'BTCUSDT', positionAmount: '1' }]);
+
+ // When the caller reads each supported account endpoint.
+ const wallets = api.handle({ pathname: ACCOUNT_PATHS.wallets, method: 'GET' });
+ const positions = api.handle({ pathname: ACCOUNT_PATHS.positions, method: 'POST', body: {} });
+ const transferable = api.handle({ pathname: ACCOUNT_PATHS.withdrawable, method: 'POST', body: { assetName: 'USDT' } });
+
+ // Then stable account codes and exact amounts reach the caller without business-plan inference.
+ assert.deepEqual(wallets.body.data.map(wallet => [wallet.accountType, wallet.assetBalances[0].free]),
+ [['CARD', '50'], ['MAIN', '40'], ['FUTURE', '10']]);
+ assert.deepEqual(positions.body, { success: true, data: [{ symbol: 'BTCUSDT', positionAmount: '1' }] });
+ assert.deepEqual(transferable.body, { success: true, data: '10' });
+});
diff --git a/test/unit/auto-refresh.test.js b/test/unit/auto-refresh.test.js
index 5806060..9133681 100644
--- a/test/unit/auto-refresh.test.js
+++ b/test/unit/auto-refresh.test.js
@@ -1,50 +1,149 @@
import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
import vm from 'node:vm';
import test from 'node:test';
import assert from 'node:assert/strict';
-const source = await readFile(new URL('../../scripts/auto_refresh.user.js', import.meta.url), 'utf8');
-
-test('focus after the scheduled target reloads instead of moving the target to tomorrow', () => {
- let now = new Date(2026, 7, 23, 7, 0, 0).getTime();
- let reloads = 0;
- const windowListeners = new Map();
- const documentListeners = new Map();
-
- class FakeDate extends Date {
- constructor(...args) {
- super(...(args.length ? args : [now]));
- }
-
- static now() {
- return now;
- }
- }
+const artifact = new URL('../../scripts/auto_refresh.user.js', import.meta.url);
+const source = await readFile(artifact, 'utf8');
+function refreshHost(t, now, url = 'https://anyrouter.top/console') {
+ t.mock.timers.enable({ apis: ['Date', 'setTimeout', 'setInterval'], now });
+ const window = new EventTarget();
+ const document = new EventTarget();
+ document.hidden = false;
+ const menus = new Map(), alerts = [], reloads = [];
+ const location = { href: url, reload() { reloads.push(Date.now()); } };
const context = {
- Date: FakeDate,
- location: {
- href: 'https://anyrouter.top/console',
- reload() { reloads += 1; },
- },
- window: {
- addEventListener(type, listener) { windowListeners.set(type, listener); },
- },
- document: {
- hidden: false,
- addEventListener(type, listener) { documentListeners.set(type, listener); },
- },
- setTimeout() { return 1; },
- clearTimeout() {},
- setInterval() { return 2; },
- GM_registerMenuCommand() {},
- alert() {},
+ Date, location, window, document, setTimeout, clearTimeout, setInterval,
+ GM_registerMenuCommand(name, action) { menus.set(name, action); },
+ alert(message) { alerts.push(message); },
console: { log() {} },
};
+ return {
+ window, document, location, menus, alerts, reloads, clock: t.mock.timers,
+ start() { vm.runInNewContext(source, context, { filename: fileURLToPath(artifact) }); },
+ visibility(hidden) { document.hidden = hidden; document.dispatchEvent(new Event('visibilitychange')); },
+ };
+}
+
+test('user reloads after regaining focus past the scheduled target without postponing it', t => {
+ // Given a matching page scheduled today's 08:03 refresh while visible at 07:00
+ const host = refreshHost(t, new Date(2026, 7, 23, 7).getTime());
+ host.start();
+
+ // When focus returns after the target while suspended timers have not fired
+ const resumedAt = new Date(2026, 7, 23, 8, 10).getTime();
+ host.clock.setTime(resumedAt);
+ host.window.dispatchEvent(new Event('focus'));
+
+ // Then focus requests a reload immediately rather than scheduling tomorrow
+ assert.deepEqual(host.reloads, [resumedAt]);
+});
+
+test('user gets exactly one scheduled reload after repeated focus and manual rescheduling', t => {
+ // Given a matching page starts one minute before its daily target
+ const now = new Date(2026, 7, 23, 8, 2).getTime();
+ const host = refreshHost(t, now);
+ host.start();
+
+ // When focus, visibility, and the menu recalculate the same target before it arrives
+ host.window.dispatchEvent(new Event('focus'));
+ host.visibility(true);
+ host.visibility(false);
+ host.menus.get('立即重新计算并安排')();
+ host.clock.tick(59_999);
+ assert.deepEqual(host.reloads, []);
+ host.clock.tick(1);
+
+ // Then replacing the pending timeout still requests only one reload at 08:03
+ assert.deepEqual(host.reloads, [now + 60_000]);
+ assert.deepEqual(host.alerts, ['已重新安排']);
+});
+
+test('user schedules tomorrow when opening the page after today\'s target', t => {
+ // Given a matching page opens one minute after today's scheduled target
+ const now = new Date(2026, 7, 23, 8, 4).getTime();
+ const tomorrow = new Date(2026, 7, 24, 8, 3).getTime();
+ const host = refreshHost(t, now);
+ host.start();
+
+ // When the user inspects the target and advances to its next occurrence
+ host.menus.get('显示下一次自动刷新时间')();
+ host.clock.tick(tomorrow - now - 1);
+ assert.deepEqual(host.reloads, []);
+ host.clock.tick(1);
+
+ // Then the menu and actual reload agree on tomorrow's 08:03 target
+ assert.deepEqual(host.alerts, [`下一次自动刷新: ${new Date(tomorrow).toLocaleString()}`]);
+ assert.deepEqual(host.reloads, [tomorrow]);
+});
+
+test('user leaves nonmatching pages untouched even when invoking the scheduling menu', t => {
+ // Given the installed script opens on a URL outside its exact console route
+ const host = refreshHost(t, new Date(2026, 7, 23, 7).getTime(), 'https://anyrouter.top/other');
+ host.start();
+
+ // When the menu, focus, and visibility events occur across daily target times
+ host.menus.get('立即重新计算并安排')();
+ host.window.dispatchEvent(new Event('focus'));
+ host.visibility(false);
+ host.clock.tick(48 * 60 * 60 * 1_000);
+
+ // Then no business timer or installed event listener requests a reload
+ assert.deepEqual(host.reloads, []);
+ assert.equal(host.menus.size, 2);
+});
+
+test('user receives no immediate refresh after leaving the matching route', t => {
+ // Given the active console has scheduled a later daily refresh
+ const now = new Date(2026, 7, 23, 7).getTime();
+ const host = refreshHost(t, now);
+ host.start();
+
+ // When an SPA transition leaves the route before the periodic check occurs
+ host.location.href = 'https://anyrouter.top/other';
+ host.clock.tick(30_000);
+ host.window.dispatchEvent(new Event('focus'));
+
+ // Then the off-route periodic and focus handlers request no immediate reload
+ assert.deepEqual(host.reloads, []);
+ assert.equal(host.location.href, 'https://anyrouter.top/other');
+});
+
+test('user can leave the console before its deadline without reloading the new route', t => {
+ // Given the console schedules a refresh one minute in the future
+ const host = refreshHost(t, new Date(2026, 7, 23, 8, 2).getTime());
+ host.start();
+
+ // When an SPA route change remains outside the console through the original deadline
+ host.location.href = 'https://anyrouter.top/other';
+ host.clock.tick(60_000);
+
+ // Then both the periodic check and scheduled deadline leave that route untouched
+ assert.deepEqual(host.reloads, []);
+ assert.equal(host.location.href, 'https://anyrouter.top/other');
+});
+
+test('user consumes a missed refresh once after returning to the console route', t => {
+ // Given the console is left before its already scheduled deadline
+ const now = new Date(2026, 7, 23, 8, 2).getTime();
+ const host = refreshHost(t, now);
+ host.start();
+ host.location.href = 'https://anyrouter.top/other';
+ host.clock.tick(60_000);
+ assert.deepEqual(host.reloads, []);
- vm.runInNewContext(source, context);
- now = new Date(2026, 7, 23, 8, 10, 0).getTime();
- windowListeners.get('focus')();
+ // When focus returns to the console thirty seconds after that missed deadline
+ host.clock.tick(30_000);
+ host.location.href = 'https://anyrouter.top/console';
+ host.window.dispatchEvent(new Event('focus'));
+ host.clock.tick(0);
+ host.window.dispatchEvent(new Event('focus'));
+ host.visibility(false);
+ host.clock.tick(30_000);
- assert.equal(reloads, 1);
+ // Then the overdue target is consumed once despite later focus and periodic checks
+ assert.deepEqual(host.reloads, [now + 90_000]);
+ assert.equal(host.location.href, 'https://anyrouter.top/console');
});
diff --git a/test/unit/binance-data-panel-lifecycle-regressions.test.js b/test/unit/binance-data-panel-lifecycle-regressions.test.js
index b37a618..108631d 100644
--- a/test/unit/binance-data-panel-lifecycle-regressions.test.js
+++ b/test/unit/binance-data-panel-lifecycle-regressions.test.js
@@ -1,124 +1,322 @@
-import { readFile } from 'node:fs/promises';
-import test from 'node:test';
import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+ activateTradingData, afterDataMediaResponseTurn, completeCmcData,
+ completeTradingBatch, createDataPanelHost, cmcDetail, tradingDataset,
+} from '../helpers/data-media-migration-host.js';
-const sources = {
- trading: await readFile(new URL('../../src/binance-trading-data/index.user.js', import.meta.url), 'utf8'),
- cmc: await readFile(new URL('../../src/binance-coinmarketcap-data/index.user.js', import.meta.url), 'utf8'),
-};
-
-function readFunctionBody(source, name) {
- const start = source.indexOf(`function ${name}`);
- assert.notEqual(start, -1, `${name} should exist`);
- const braceStart = source.indexOf('{', start);
- let depth = 0;
- for (let index = braceStart; index < source.length; index += 1) {
- const char = source[index];
- if (char === '{') depth += 1;
- if (char === '}') depth -= 1;
- if (depth === 0) return source.slice(braceStart + 1, index);
- }
- assert.fail(`${name} body should be closed`);
+async function finishInitial(host, kind) {
+ if (kind === 'trading') await activateTradingData(host);
+ else await completeCmcData(host);
}
-for (const [name, source] of Object.entries(sources)) {
- test(`${name} data panel removes document drag listeners when panel is removed`, () => {
- const setupDragBody = readFunctionBody(source, 'setupDrag');
- const removePanelBody = readFunctionBody(source, 'removePanel');
- assert.match(setupDragBody, /removeEventListener\('mousemove'/);
- assert.match(setupDragBody, /removeEventListener\('mouseup'/);
- assert.match(removePanelBody, /cleanupPanelDrag\(\)/);
+for (const kind of ['trading', 'cmc']) {
+ test(`user starts the hidden ${kind} panel only after returning to the tab`, { timeout: 5_000 }, async t => {
+ // Given installation occurs on the current trading route while the document is hidden
+ const host = createDataPanelHost(t, kind, { hidden: true });
+ await host.start();
+ host.clock.tick(60_000);
+ assert.equal(host.network.requests.length, 0);
+ assert.equal(host.panel(), null);
+
+ // When the document becomes visible without any route change
+ host.setHidden(false);
+ await finishInitial(host, kind);
+
+ // Then the current Bitcoin panel renders one initial request batch
+ assert.match(host.element('symbol').textContent, /^BTC/);
+ assert.equal(host.document.querySelectorAll(`#${host.panelId}`).length, 1);
+ assert.equal(host.network.requests.length, kind === 'trading' ? 8 : 3);
+ });
+
+ test(`user operates a ${kind} header control without dragging or saving a new position`, { timeout: 5_000 }, async t => {
+ // Given a rendered panel retains its existing viewport position
+ const host = createDataPanelHost(t, kind);
+ await host.start();
+ await finishInitial(host, kind);
+ const panel = host.panel();
+ const position = panel.style.cssText;
+ const positionKey = kind === 'trading' ? 'jh_binance_trading_data_pos' : 'jh_binance_cmc_data_pos';
+ const savedPosition = host.window.localStorage.getItem(positionKey);
+ const collapse = host.element('collapse');
+
+ // When idle pointer events and a collapse-button press are followed by pointer movement
+ host.document.dispatchEvent(new host.window.MouseEvent('mousemove', { clientX: 100, clientY: 100 }));
+ host.document.dispatchEvent(new host.window.MouseEvent('mouseup'));
+ collapse.dispatchEvent(new host.window.MouseEvent('mousedown', { bubbles: true, clientX: 10, clientY: 10 }));
+ host.document.dispatchEvent(new host.window.MouseEvent('mousemove', { clientX: 400, clientY: 400 }));
+ host.document.dispatchEvent(new host.window.MouseEvent('mouseup'));
+ collapse.click();
+ host.clock.tick(16);
+
+ // Then the control collapses content while the panel position remains exactly unchanged
+ assert.equal(host.element('body').style.display, 'none');
+ assert.equal(panel.style.cssText, position);
+ assert.equal(host.window.localStorage.getItem(positionKey), savedPosition);
+ });
+
+ test(`user stops dragging a removed ${kind} panel when its route becomes inactive`, { timeout: 5_000 }, async t => {
+ // Given a fully rendered panel whose header has started a drag
+ const host = createDataPanelHost(t, kind);
+ await host.start();
+ await finishInitial(host, kind);
+ const panel = host.panel();
+ host.element('header').dispatchEvent(new host.window.MouseEvent('mousedown', { bubbles: true, clientX: 10, clientY: 10 }));
+
+ // When leaving the route removes the panel before the next pointer movement
+ host.navigate('/zh-CN/futures');
+ const position = panel.style.cssText;
+ host.document.dispatchEvent(new host.window.MouseEvent('mousemove', { clientX: 400, clientY: 400 }));
+ host.document.dispatchEvent(new host.window.MouseEvent('mouseup'));
+ host.clock.tick(16);
+
+ // Then detached drag handlers cannot alter the removed panel
+ assert.equal(host.panel(), null);
+ assert.equal(panel.style.cssText, position);
});
- test(`${name} data panel removes beforeunload listener when panel is removed`, () => {
- const sourceText = source;
- const removePanelBody = readFunctionBody(source, 'removePanel');
- assert.match(sourceText, /removeEventListener\('beforeunload'/);
- assert.match(removePanelBody, /cleanupPanelUnload\(\)/);
+ test(`user keeps later saved positions after the ${kind} panel removes its unload listener`, { timeout: 5_000 }, async t => {
+ // Given a rendered panel with its normal unload persistence listener
+ const host = createDataPanelHost(t, kind);
+ await host.start();
+ await finishInitial(host, kind);
+ const positionKey = kind === 'trading' ? 'jh_binance_trading_data_pos' : 'jh_binance_cmc_data_pos';
+
+ // When the panel is removed and another valid position is saved before unloading
+ host.navigate('/zh-CN/futures');
+ host.window.localStorage.setItem(positionKey, '{"left":700,"top":300}');
+ host.window.dispatchEvent(new host.window.Event('beforeunload'));
+
+ // Then the old panel cannot overwrite the later persisted position
+ assert.equal(host.window.localStorage.getItem(positionKey), '{"left":700,"top":300}');
+ });
+
+ test(`user pauses ${kind} business requests off-route and can return through the retained route watcher`, { timeout: 5_000 }, async t => {
+ // Given a completed panel refresh on the current trading route
+ const host = createDataPanelHost(t, kind);
+ await host.start();
+ await finishInitial(host, kind);
+
+ // When the user leaves trading, waits through business deadlines, and returns
+ host.navigate('/zh-CN/my/wallet/futures/overview');
+ const beforePause = host.network.requests.length;
+ host.clock.tick(3_600_000);
+ assert.equal(host.network.requests.length, beforePause);
+ assert.equal(host.panel(), null);
+ host.navigate('/zh-CN/futures/BTCUSDT');
+ if (kind === 'trading') await activateTradingData(host);
+ else await completeCmcData(host, cmcDetail(), { map: false });
+
+ // Then a new current-symbol refresh renders after route reactivation
+ assert.equal(host.panel().style.width, '240px');
+ assert.match(host.element('symbol').textContent, /^BTC/);
+ assert.ok(host.network.requests.length > beforePause);
+ });
+
+ test(`user can open the ${kind} panel after a hidden non-trading cold start`, { timeout: 5_000 }, async t => {
+ // Given installation occurs in a hidden document on the futures landing route
+ const host = createDataPanelHost(t, kind, { path: '/zh-CN/futures', hidden: true });
+ await host.start();
+ host.clock.tick(60_000);
+ assert.equal(host.network.requests.length, 0);
+
+ // When the user returns to the tab and enters a supported trading route
+ host.setHidden(false);
+ assert.equal(host.network.requests.length, 0);
+ host.navigate('/zh-CN/futures/BTCUSDT');
+ await finishInitial(host, kind);
+
+ // Then the route watcher creates exactly one correctly identified panel
+ assert.equal(host.document.querySelectorAll(`#${host.panelId}`).length, 1);
+ assert.match(host.element('symbol').textContent, /^BTC/);
+ });
+
+ test(`user sees compact ${kind} row layout in the generated panel DOM`, { timeout: 5_000 }, async t => {
+ // Given the complete installed entrypoint runs on a futures page
+ const host = createDataPanelHost(t, kind);
+ await host.start();
+
+ // When all initial data requests complete
+ await finishInitial(host, kind);
+ const firstRow = host.element('rows').firstElementChild;
+
+ // Then the actual styles reserve stable label and value space inside 240 pixels
+ assert.equal(host.panel().style.width, '240px');
+ assert.equal(firstRow.children[1].style.fontVariantNumeric, 'tabular-nums');
+ assert.equal(firstRow.children[1].style.textAlign, 'right');
+ if (kind === 'trading') {
+ assert.equal(firstRow.children[0].style.minWidth, '90px');
+ assert.equal(firstRow.children[1].style.flex, '1 1 0%');
+ } else {
+ assert.equal(firstRow.children[0].style.overflow, 'hidden');
+ assert.equal(firstRow.children[0].style.textOverflow, 'ellipsis');
+ assert.equal(firstRow.children[1].style.whiteSpace, 'nowrap');
+ assert.equal(firstRow.children[1].style.flex, '0 0 auto');
+ }
+ });
+
+ test(`user keeps the new symbol when a superseded ${kind} response arrives late`, { timeout: 5_000 }, async t => {
+ // Given the original Bitcoin request remains pending while the user changes symbol
+ const host = createDataPanelHost(t, kind);
+ await host.start();
+ if (kind === 'trading') {
+ host.network.requests[0].respond({ serverTime: Date.now() });
+ await host.network.waitForRequest(request => request.url.pathname.endsWith('/fundingRate'));
+ }
+
+ // When Ethereum renders before the old Bitcoin request is allowed to finish
+ host.navigate('/zh-CN/futures/ETHUSDT');
+ if (kind === 'trading') {
+ await activateTradingData(host, tradingDataset(Date.now(), { oi: 3000 }), { symbol: 'ETHUSDT' });
+ await completeTradingBatch(host, tradingDataset(Date.now()), { symbol: 'BTCUSDT' });
+ } else {
+ await completeCmcData(host, cmcDetail({ id: 2, symbol: 'ETH' }), { symbol: 'ETH', slug: 'ethereum' });
+ await completeCmcData(host);
+ }
+ await afterDataMediaResponseTurn();
+
+ // Then the late response cannot replace the displayed Ethereum identity or data
+ assert.match(host.element('symbol').textContent, /^ETH/);
+ if (kind === 'trading') assert.match(host.element('rows').textContent, /3K ▼/);
+ else assert.equal(host.element('footer').querySelector('a').href, 'https://coinmarketcap.com/zh/currencies/ethereum/');
});
}
-test('trading data panel does not render after close, hidden, or non-trading route', () => {
- const renderPanelBody = readFunctionBody(sources.trading, 'renderPanel');
- assert.match(sources.trading, /function isActiveTradingPage\(\)/);
- assert.match(renderPanelBody, /if \(!isActiveTradingPage\(\)\) return;/);
-});
+for (const state of ['hidden', 'off-route']) {
+ test(`user starts no trading data batch when server synchronization finishes after becoming ${state}`, { timeout: 5_000 }, async t => {
+ // Given the initial server-time request is still pending before the panel mounts
+ const host = createDataPanelHost(t, 'trading');
+ await host.start();
+ const timeRequest = host.network.requests[0];
+ assert.equal(host.panel(), null);
-test('trading data panel invalidates async work on route pause and rejects stale symbols after awaits', () => {
- const pauseBody = readFunctionBody(sources.trading, 'pauseForNonTradingPage');
- const initialFetchBody = readFunctionBody(sources.trading, 'initialFetch');
- const cycleBody = readFunctionBody(sources.trading, 'runCycleAttempt');
- const scheduleBody = readFunctionBody(sources.trading, 'scheduleCycle');
- assert.match(pauseBody, /epoch\+\+/);
- assert.match(initialFetchBody, /getCurrentSymbol\(\) !== symbol/);
- assert.match(cycleBody, /getCurrentSymbol\(\) !== symbol/);
- assert.match(scheduleBody, /!isFuturesTradingPage\(\)/);
-});
+ // When the route or document becomes inactive before synchronization completes
+ if (state === 'hidden') host.setHidden(true);
+ else host.navigate('/zh-CN/futures');
+ timeRequest.respond({ serverTime: Date.now() });
+ await afterDataMediaResponseTurn();
+ host.clock.tick(60_000);
-test('trading data panel keeps a narrower fixed width with stable row value space', () => {
- assert.match(sources.trading, /const PANEL_WIDTH = 240;/);
+ // Then synchronization cannot mount a panel or start any period endpoints
+ assert.equal(host.panel(), null);
+ assert.deepEqual(host.network.requests.map(request => request.url.pathname), ['/fapi/v1/time']);
+ });
+}
- const ensurePanelBody = readFunctionBody(sources.trading, 'ensurePanel');
- assert.match(ensurePanelBody, /width:\s+PANEL_WIDTH \+ 'px'/);
+for (const state of ['closed', 'hidden', 'off-route']) {
+ test(`user receives no late CMC error after the loading panel becomes ${state}`, { timeout: 5_000 }, async t => {
+ // Given the CMC panel is waiting for its initial asset mapping
+ const host = createDataPanelHost(t, 'cmc');
+ await host.start();
+ const mapping = host.network.requests[0];
+ const rows = host.element('rows');
+ const before = rows.innerHTML;
+ const panel = host.panel();
- const renderPanelBody = readFunctionBody(sources.trading, 'renderPanel');
- assert.match(renderPanelBody, /min-width:90px/);
- assert.match(renderPanelBody, /font-variant-numeric:tabular-nums;flex:1;text-align:right/);
-});
+ // When the panel becomes inactive before the mapping reports failure
+ if (state === 'closed') host.element('close').click();
+ else if (state === 'hidden') host.setHidden(true);
+ else host.navigate('/zh-CN/futures');
+ mapping.fail('error');
+ await afterDataMediaResponseTurn();
-test('CMC data panel stops business timers on non-trading routes but keeps a route watcher', () => {
- const pauseBody = readFunctionBody(sources.cmc, 'pauseForNonTradingPage');
- const startRouteBody = readFunctionBody(sources.cmc, 'startRouteWatcher');
- assert.match(pauseBody, /stopDataLoop\(\)/);
- assert.doesNotMatch(pauseBody, /stopRouteWatcher\(\)/);
- assert.match(startRouteBody, /installSpaRouteChangeListener/);
- assert.match(startRouteBody, /setInterval/);
- assert.match(startRouteBody, /ROUTE_WATCHDOG_MS/);
- assert.doesNotMatch(sources.cmc, /symbolTimer|SYMBOL_CHECK_MS/);
-});
+ // Then the abandoned loading state is not rewritten as a current request failure
+ assert.equal(rows.innerHTML, before);
+ assert.equal(panel.isConnected, state !== 'off-route');
+ assert.equal(host.network.requests.length, 1);
+ if (state === 'closed') assert.equal(panel.style.display, 'none');
+ });
+}
-test('CMC data panel invalidates superseded and paused refreshes with a monotonic epoch', () => {
- const refreshBody = readFunctionBody(sources.cmc, 'refreshForCurrentSymbol');
- const stopDataBody = readFunctionBody(sources.cmc, 'stopDataLoop');
- assert.match(sources.cmc, /let refreshEpoch = 0;/);
- assert.match(refreshBody, /const myEpoch = \+\+refreshEpoch/);
- assert.match(refreshBody, /myEpoch !== refreshEpoch/);
- assert.match(refreshBody, /document\.hidden/);
- assert.match(stopDataBody, /refreshEpoch\+\+/);
- assert.match(stopDataBody, /inFlightSymbol = null/);
-});
+for (const state of ['closed', 'hidden', 'off-route', 'new symbol']) {
+ test(`user ignores an old trading cycle response after entering ${state}`, { timeout: 5_000 }, async t => {
+ // Given an already-rendered panel has started the next scheduled five-minute refresh
+ const host = createDataPanelHost(t, 'trading');
+ await host.start();
+ await activateTradingData(host);
+ host.clock.tick(305_000);
+ await host.network.waitForRequest(request => !request.settled && request.url.pathname.endsWith('/fundingRate'));
+ const oldRequests = host.network.requests.filter(request => !request.settled);
+ assert.equal(oldRequests.length, 7);
+ const oldPanel = host.panel();
+ const oldRows = host.element('rows');
-for (const [name, source] of Object.entries(sources)) {
- test(`${name} data panel installs route watching from a matched non-trading cold start`, () => {
- const startupPrefix = source.slice(0, source.indexOf('const PANEL_ID'));
- assert.doesNotMatch(startupPrefix, /if \(!isFuturesTradingPage\(\)\) return;/);
- assert.match(source, /startRouteWatcher\(\)/);
- const startRouteBody = readFunctionBody(source, 'startRouteWatcher');
- assert.match(startRouteBody, /installSpaRouteChangeListener/);
- assert.match(startRouteBody, /ROUTE_WATCHDOG_MS/);
+ // When lifecycle invalidation or a symbol change precedes the old cycle completion
+ if (state === 'closed') host.element('close').click();
+ else if (state === 'hidden') host.setHidden(true);
+ else if (state === 'off-route') host.navigate('/zh-CN/futures');
+ else {
+ host.navigate('/zh-CN/futures/ETHUSDT');
+ await activateTradingData(host, tradingDataset(Date.now(), { oi: 3000 }), { symbol: 'ETHUSDT' });
+ }
+ const rows = state === 'new symbol' ? host.element('rows') : oldRows;
+ const before = rows.innerHTML;
+ const stale = tradingDataset(Date.now(), { oi: 9_000_000, ratio: 0.5, basis: -0.02, funding: 0.001 });
+ oldRequests.forEach(request => request.respond(stale[request.url.pathname.split('/').at(-1)]));
+ await afterDataMediaResponseTurn();
+
+ // Then the superseded scheduled batch cannot alter inactive or current-symbol rows
+ assert.equal(rows.innerHTML, before);
+ assert.equal(oldPanel.isConnected, state !== 'off-route');
+ if (state === 'new symbol') {
+ assert.match(host.element('symbol').textContent, /^ETH/);
+ assert.match(rows.textContent, /3K ▼/);
+ }
+ if (state === 'closed') assert.equal(oldPanel.style.display, 'none');
});
}
-test('trading data server-time interval follows the business lifecycle', () => {
- const stopBusinessBody = readFunctionBody(sources.trading, 'stopBusinessLoop');
- const startServerBody = readFunctionBody(sources.trading, 'startServerTimeLoop');
- assert.match(sources.trading, /let serverTimeTimer = null;/);
- assert.match(startServerBody, /serverTimeTimer = setInterval/);
- assert.match(stopBusinessBody, /clearInterval\(serverTimeTimer\)/);
-});
+for (const state of ['closed', 'hidden', 'off-route']) {
+ test(`user receives no stale trading render after the panel becomes ${state}`, { timeout: 5_000 }, async t => {
+ // Given the panel exists but its initial data responses remain pending
+ const host = createDataPanelHost(t, 'trading');
+ await host.start();
+ host.network.requests[0].respond({ serverTime: Date.now() });
+ await host.network.waitForRequest(request => request.url.pathname.endsWith('/fundingRate'));
+ const panel = host.panel();
+ const rows = host.element('rows');
+
+ // When the lifecycle is invalidated before the pending responses finish
+ if (state === 'closed') host.element('close').click();
+ else if (state === 'hidden') host.setHidden(true);
+ else host.navigate('/zh-CN/futures');
+ await completeTradingBatch(host, tradingDataset(Date.now()));
+ await afterDataMediaResponseTurn();
+
+ // Then the pending request cannot write its rows into the inactive panel
+ assert.equal(rows.innerHTML, '');
+ assert.equal(panel.isConnected, state !== 'off-route');
+ if (state === 'closed') assert.equal(panel.style.display, 'none');
+ });
+}
+
+test('user stops the trading server clock sync while the document is hidden', { timeout: 5_000 }, async t => {
+ // Given one initial server-time synchronization has completed
+ const host = createDataPanelHost(t, 'trading');
+ await host.start();
+ await activateTradingData(host);
+ const timeCount = () => host.network.requests.filter(request => request.url.pathname.endsWith('/time')).length;
+
+ // When an hourly deadline occurs and the following hour is spent hidden
+ host.clock.tick(3_600_000);
+ assert.equal(timeCount(), 2);
+ host.setHidden(true);
+ host.clock.tick(3_600_000);
-test('CMC data panel escapes the CoinMarketCap link href before writing innerHTML', () => {
- const renderDataBody = readFunctionBody(sources.cmc, 'renderData');
- assert.match(renderDataBody, /escapeHtml\(data\.url\)/);
+ // Then the hidden panel cannot perform another server synchronization
+ assert.equal(timeCount(), 2);
});
-test('CMC data panel keeps a compact fixed width without row overflow', () => {
- assert.match(sources.cmc, /const PANEL_WIDTH = 240;/);
+test('user opens a correctly escaped CMC link when its asset slug contains quotes', { timeout: 5_000 }, async t => {
+ // Given the API mapping returns a slug whose quotation mark must stay inside the URL
+ const host = createDataPanelHost(t, 'cmc');
+ await host.start();
- const ensurePanelBody = readFunctionBody(sources.cmc, 'ensurePanel');
- assert.match(ensurePanelBody, /width: PANEL_WIDTH \+ 'px'/);
+ // When the complete data response renders that mapped asset link
+ await completeCmcData(host, cmcDetail(), { slug: 'bitcoin" data-extra="unexpected' });
+ const link = host.element('footer').querySelector('a');
- const renderDataBody = readFunctionBody(sources.cmc, 'renderData');
- assert.match(renderDataBody, /overflow:hidden;text-overflow:ellipsis;min-width:0/);
- assert.match(renderDataBody, /white-space:nowrap;flex:0 0 auto/);
+ // Then the quote remains URL content and cannot create an extra HTML attribute
+ assert.equal(link.getAttribute('href'), 'https://coinmarketcap.com/zh/currencies/bitcoin" data-extra="unexpected/');
+ assert.equal(link.hasAttribute('data-extra'), false);
});
diff --git a/test/unit/binance-data-panel-route-regressions.test.js b/test/unit/binance-data-panel-route-regressions.test.js
index 1b89fc8..21d65c5 100644
--- a/test/unit/binance-data-panel-route-regressions.test.js
+++ b/test/unit/binance-data-panel-route-regressions.test.js
@@ -1,53 +1,35 @@
import { readFile } from 'node:fs/promises';
import test from 'node:test';
import assert from 'node:assert/strict';
+import { createDataPanelHost, activateTradingData, completeCmcData, cmcDetail, tradingDataset } from '../helpers/data-media-migration-host.js';
-const scripts = [
- {
- name: 'CoinMarketCap data panel',
- path: '../../scripts/binance-coinmarketcap-data.user.js',
- },
- {
- name: 'trading data panel',
- path: '../../scripts/binance-trading-data.user.js',
- },
-];
-
-async function readScript(path) {
- return readFile(new URL(path, import.meta.url), 'utf8');
-}
-
-function readFunctionBody(source, name) {
- const start = source.indexOf(`function ${name}`);
- assert.notEqual(start, -1, `${name} should exist`);
- const braceStart = source.indexOf('{', start);
- let depth = 0;
- for (let index = braceStart; index < source.length; index += 1) {
- const char = source[index];
- if (char === '{') depth += 1;
- if (char === '}') depth -= 1;
- if (depth === 0) return source.slice(braceStart + 1, index);
- }
- assert.fail(`${name} body should be closed`);
-}
-
-for (const script of scripts) {
- test(`${script.name} excludes Binance wallet futures paths`, async () => {
- const source = await readScript(script.path);
+for (const kind of ['cmc', 'trading']) {
+ test(`user excludes wallet futures pages when installing the ${kind} data panel`, async () => {
+ // Given the script is installed through its public generated artifact
+ const artifact = new URL(`../../scripts/binance-${kind === 'trading' ? 'trading' : 'coinmarketcap'}-data.user.js`, import.meta.url);
+ // When the install metadata is read
+ const source = await readFile(artifact, 'utf8');
+ // Then both localized and root wallet routes have explicit exclusions
assert.match(source, /\/\/ @exclude\s+https:\/\/www\.binance\.com\/\*\/my\/wallet\/futures\/\*/);
assert.match(source, /\/\/ @exclude\s+https:\/\/www\.binance\.com\/my\/wallet\/futures\/\*/);
});
- test(`${script.name} parses only actual futures trading page symbols`, async () => {
- const source = await readScript(script.path);
- assert.match(source, /\b(?:const|var) FUTURES_TRADING_PATH_RE = \/\^\\\/\(\?:\[a-z\]\{2\}/);
- assert.match(source, /function isFuturesTradingPage\(\)/);
- const startupPrefix = source.slice(0, source.indexOf('const PANEL_ID'));
- assert.doesNotMatch(startupPrefix, /if \(!isFuturesTradingPage\(\)\) return;/);
+ test(`user sees only the route symbol in the ${kind} panel despite an unrelated page title`, { timeout: 5_000 }, async t => {
+ // Given a matched futures landing page carries a stale Bitcoin title
+ const host = createDataPanelHost(t, kind, { path: '/zh-CN/futures' });
+ host.document.title = 'BTCUSDT futures';
+ await host.start();
+ assert.equal(host.panel(), null);
+ assert.equal(host.network.requests.length, 0);
+
+ // When SPA navigation enters a Unicode futures trading route
+ host.navigate('/zh-CN/futures/龙虾USDT');
+ if (kind === 'trading') await activateTradingData(host, tradingDataset(Date.now()), { symbol: '龙虾USDT' });
+ else await completeCmcData(host, cmcDetail({ id: 42, symbol: '龙虾' }), { symbol: '龙虾', slug: 'lobster' });
- const getSymbolBody = readFunctionBody(source, 'getCurrentSymbol');
- assert.match(getSymbolBody, /parseFuturesTradingSymbolFromPathname\(location\.pathname\)/);
- assert.doesNotMatch(getSymbolBody, /document\.title/);
- assert.doesNotMatch(getSymbolBody, /\/\\\/futures\\\/\(\[A-Z0-9_\]\+\)/);
+ // Then the route controls the visible identity and the outbound symbol parameters
+ assert.match(host.element('symbol').textContent, /^龙虾/);
+ assert.equal(host.network.requests.some(request => request.url.searchParams.get('symbol')?.includes('BTC')), false);
+ assert.equal(host.document.title, 'BTCUSDT futures');
});
}
diff --git a/test/unit/binance-data-panel-symbols.test.js b/test/unit/binance-data-panel-symbols.test.js
index f2aa73a..ac02c15 100644
--- a/test/unit/binance-data-panel-symbols.test.js
+++ b/test/unit/binance-data-panel-symbols.test.js
@@ -1,21 +1,21 @@
-import { readFile } from 'node:fs/promises';
import test from 'node:test';
import assert from 'node:assert/strict';
+import { createDataPanelHost, completeCmcData, cmcDetail } from '../helpers/data-media-migration-host.js';
-const source = await readFile(new URL('../../src/binance-coinmarketcap-data/index.user.js', import.meta.url), 'utf8');
-const start = source.indexOf(' function baseAssetFromSymbol(');
-const end = source.indexOf(' function normalizeCmcAsset(', start);
-assert(start >= 0 && end > start);
-const { baseAssetFromSymbol, cmcSymbolFromBaseAsset } = new Function(
- `${source.slice(start, end)}\nreturn { baseAssetFromSymbol, cmcSymbolFromBaseAsset };`,
-)();
-
-test('CMC mapping retains Unicode and numeric base assets and removes only supported multipliers', () => {
- for (const [symbol, expected] of [
- ['龙虾USDT', '龙虾'], ['币安人生USDC', '币安人生'], ['4USDT', '4'],
- ['1INCHUSDT', '1INCH'], ['1000PEPEUSDT', 'PEPE'], ['1000龙虾USDT', '龙虾'],
- ['1000000龙虾USDT', '龙虾'], ['10000001USDT', '10000001'],
- ]) {
- assert.equal(cmcSymbolFromBaseAsset(baseAssetFromSymbol(symbol)), expected, symbol);
- }
-});
+for (const [symbol, expected] of [
+ ['龙虾USDT', '龙虾'], ['币安人生USDC', '币安人生'], ['4USDT', '4'],
+ ['1INCHUSDT', '1INCH'], ['1000PEPEUSDT', 'PEPE'], ['1000龙虾USDT', '龙虾'],
+ ['1000000龙虾USDT', '龙虾'], ['10000001USDT', '10000001'],
+]) {
+ test(`user maps ${symbol} to the exact CMC asset ${expected}`, { timeout: 5_000 }, async t => {
+ // Given the complete CMC entrypoint receives a Unicode or numeric futures route
+ const host = createDataPanelHost(t, 'cmc', { path: `/futures/${symbol}` });
+ // When the map and detail endpoints resolve that route's base asset
+ await host.start();
+ await completeCmcData(host, cmcDetail({ id: 42, symbol: expected }), { symbol: expected, slug: 'fixture-asset' });
+ // Then the CMC request removes only supported multipliers and preserves asset identity
+ const mapping = host.network.requests.find(request => request.url.pathname.endsWith('/map'));
+ assert.equal(mapping.url.searchParams.get('symbol'), expected);
+ assert.equal(host.element('symbol').textContent, `${expected} #1`);
+ });
+}
diff --git a/test/unit/binance-fixture-contract.test.js b/test/unit/binance-fixture-contract.test.js
index 1775895..c64df90 100644
--- a/test/unit/binance-fixture-contract.test.js
+++ b/test/unit/binance-fixture-contract.test.js
@@ -42,6 +42,8 @@ function openNativeHost(t, scenario) {
fixture: {
snapshot: () => structuredClone(dom.window.__BINANCE_FIXTURE__.snapshot()),
switchSymbol: (symbol) => dom.window.__BINANCE_FIXTURE__.switchSymbol(symbol),
+ setPositions: (positions) => dom.window.__BINANCE_FIXTURE__.setPositions(positions),
+ setOrders: (orders) => dom.window.__BINANCE_FIXTURE__.setOrders(orders),
},
async respond(payload) {
submission.resolve(new Response(JSON.stringify(payload), {
@@ -196,3 +198,383 @@ test('user cannot configure undeclared order kinds or invalid submit outcomes',
assert.throws(constructUnknown, /unknown.*pending/);
assert.throws(constructRejection, /code and message/);
});
+
+test('user can detect an unsafe row cancellation because the fake removes exactly the clicked other-symbol order', (t) => {
+ // Given the native list contains both symbols and a delayed row cancellation.
+ const host = openNativeHost(t, createCancelScenario({
+ orders: mixedOrders,
+ ui: { accountTab: 'openOrders' },
+ host: { rowCancelDelayMs: 200 },
+ }));
+ const icon = host.document.querySelector('[data-order-id="other-1"] svg');
+
+ // When a caller clicks the wrong visible SVG row and navigates before clearing.
+ icon.dispatchEvent(new host.document.defaultView.MouseEvent('click', { bubbles: true }));
+ host.fixture.switchSymbol(OTHER_SYMBOL);
+ t.mock.timers.tick(199);
+ assert.deepEqual(host.fixture.snapshot().orders, mixedOrders);
+ t.mock.timers.tick(1);
+
+ // Then only that captured ID is removed; the fixture has not corrected the caller to the original symbol.
+ const state = host.fixture.snapshot();
+ assert.deepEqual(state.orders, [ORDER_SETS.current[0], ...protectedOrders]);
+ assert.deepEqual(state.events.filter(({ type }) => type.startsWith('row-cancel')).map(({ type, orderId }) => ({ type, orderId })), [
+ { type: 'row-cancel-requested', orderId: 'other-1' },
+ { type: 'row-cancel-cleared', orderId: 'other-1' },
+ ]);
+});
+
+for (const action of ['cancel', 'confirm']) {
+ test(`user must explicitly ${action} a native row dialog before its captured cancellation can settle`, (t) => {
+ // Given row cancellation requires a native decision and releases declared quantity only after clearing.
+ const host = openNativeHost(t, createCancelScenario({
+ orders: mixedOrders,
+ ui: { accountTab: 'openOrders', openableQuantity: '0.04' },
+ host: { rowCancelMode: 'dialog', openableQuantityAfterRowCancel: '10' },
+ }));
+ host.document.querySelector('[data-order-id="current-1"] svg')
+ .dispatchEvent(new host.document.defaultView.MouseEvent('click', { bubbles: true }));
+ t.mock.timers.tick(1000);
+ assert.deepEqual(host.fixture.snapshot().orders, mixedOrders);
+ assert.equal(host.fixture.snapshot().dialogOpen, true);
+
+ // When the user makes the declared native dialog decision.
+ host.document.querySelector('[data-row-dialog-action="' + action + '"]').click();
+ t.mock.timers.tick(0);
+
+ // Then cancellation and released quantity match that decision exactly.
+ const state = host.fixture.snapshot();
+ assert.equal(state.dialogOpen, false);
+ assert.deepEqual(state.orders, action === 'confirm' ? [ORDER_SETS.both[1], ...protectedOrders] : mixedOrders);
+ assert.equal(state.openableQuantity, action === 'confirm' ? '10' : '0.04');
+ assert.equal(host.document.querySelector('[data-testid="max-buy-amount"]').textContent,
+ '可开 ' + (action === 'confirm' ? '10' : '0.04') + ' HYPE');
+ });
+}
+
+test('user sees an unconfirmed row request stay unconfirmed after its deadline', (t) => {
+ // Given the host is explicitly unable to confirm a row cancellation.
+ const host = openNativeHost(t, createCancelScenario({
+ orders: ORDER_SETS.current,
+ ui: { accountTab: 'openOrders' },
+ host: { rowCancelMode: 'unchanged' },
+ }));
+
+ // When the caller clicks the SVG and all modeled response time has elapsed.
+ host.document.querySelector('.open-order-row svg')
+ .dispatchEvent(new host.document.defaultView.MouseEvent('click', { bubbles: true }));
+ t.mock.timers.tick(5000);
+
+ // Then no row removal or successful cancellation is fabricated.
+ assert.deepEqual(host.fixture.snapshot().orders, ORDER_SETS.current);
+ assert.deepEqual(host.fixture.snapshot().events.map(({ type }) => type), ['row-cancel-requested']);
+});
+
+for (const invalid of [
+ { ui: { openableQuantity: null } },
+ { host: { rowCancelMode: 'repair-scope' } },
+ { host: { rowCancelDelayMs: -1 } },
+ { host: { openableQuantityAfterRowCancel: -1 } },
+]) {
+ test(`user cannot configure an ambiguous row host boundary ${JSON.stringify(invalid)}`, () => {
+ // Given the row boundary contains an invalid quantity, outcome, or delay.
+ const scenario = invalid;
+
+ // When the caller declares that native boundary.
+ const construct = () => createCancelScenario(scenario);
+
+ // Then the host refuses the configuration instead of assigning silent behavior.
+ assert.throws(construct, /Openable quantity|Row cancellation/);
+ });
+}
+
+test('user can discover later native pages only by scrolling the declared host list to its bottom', (t) => {
+ // Given the external list has five explicit rows but initially mounts only two.
+ const orders = Array.from({ length: 5 }, (_, index) => ({
+ ...ORDER_SETS.current[0], id: 'page-' + index, price: String(80 + index),
+ symbol: index === 4 ? OTHER_SYMBOL : CURRENT_SYMBOL,
+ }));
+ const host = openNativeHost(t, createCancelScenario({
+ orders, ui: { accountTab: 'openOrders' }, host: { orderRowsPageSize: 2 },
+ }));
+ const content = host.document.querySelector('.orders-content');
+ Object.defineProperties(content, {
+ clientHeight: { value: 96 },
+ scrollHeight: { get: () => content.querySelectorAll('.open-order-row').length * 80 },
+ });
+ const mountedIds = () => Array.from(content.querySelectorAll('[data-order-id]'), row => row.dataset.orderId);
+ assert.deepEqual(mountedIds(), ['page-0', 'page-1']);
+
+ // When an ordinary scroll stops before the bottom of the current page.
+ content.scrollTop = 10;
+ content.dispatchEvent(new host.document.defaultView.Event('scroll'));
+
+ // Then no later page is fabricated by a non-bottom scroll.
+ assert.deepEqual(mountedIds(), ['page-0', 'page-1']);
+
+ // When two actual bottom events expose the remaining pages.
+ content.scrollTop = 64;
+ content.dispatchEvent(new host.document.defaultView.Event('scroll'));
+ assert.deepEqual(mountedIds(), ['page-0', 'page-1', 'page-2', 'page-3']);
+ content.scrollTop = 224;
+ content.dispatchEvent(new host.document.defaultView.Event('scroll'));
+
+ // Then the final unfiltered page includes its real other-symbol row and the account remains unchanged.
+ assert.deepEqual(mountedIds(), ['page-0', 'page-1', 'page-2', 'page-3', 'page-4']);
+ assert.deepEqual(host.fixture.snapshot().orders, orders);
+ assert.deepEqual(host.fixture.snapshot().events.filter(({ type }) => type === 'order-rows-page-loaded')
+ .map(({ ids }) => ids.length), [4, 5]);
+});
+
+test('user sees native row mounting wait for its declared host deadline', (t) => {
+ // Given the account tabs and filter are committed before React mounts its current rows.
+ const host = openNativeHost(t, createCancelScenario({
+ orders: mixedOrders, ui: { accountTab: 'openOrders' }, host: { orderRowsMountDelayMs: 200 },
+ }));
+ assert.equal(host.document.querySelectorAll('.open-order-row').length, 0);
+ assert.equal(host.document.querySelector('[data-orders-loading]').textContent, 'Loading orders');
+
+ // When the host reaches the exact row-mount deadline.
+ t.mock.timers.tick(199);
+ assert.equal(host.document.querySelectorAll('.open-order-row').length, 0);
+ t.mock.timers.tick(1);
+
+ // Then real current and other-symbol basic rows appear without modifying account state.
+ assert.deepEqual(Array.from(host.document.querySelectorAll('[data-order-id]'), row => row.dataset.orderId),
+ ['current-1', 'other-1']);
+ assert.equal(host.document.querySelector('[data-orders-loading]'), null);
+ assert.deepEqual(host.fixture.snapshot().orders, mixedOrders);
+});
+
+test('user cannot receive an old delayed native row mount in a newly selected symbol scope', (t) => {
+ // Given one symbol-filtered mount is pending while another symbol has different orders.
+ const host = openNativeHost(t, createCancelScenario({
+ orders: mixedOrders, ui: { accountTab: 'openOrders', hideOtherSymbols: true },
+ host: { orderRowsMountDelayMs: 200 },
+ }));
+ t.mock.timers.tick(100);
+
+ // When the symbol changes before the retired mount would complete.
+ host.fixture.switchSymbol(OTHER_SYMBOL);
+ t.mock.timers.tick(100);
+
+ // Then the old callback cannot publish rows into the new pending view.
+ assert.equal(host.document.querySelectorAll('.open-order-row').length, 0);
+ assert.deepEqual(host.fixture.snapshot().events.filter(({ type }) => type === 'order-rows-mounted'), []);
+
+ // When the new symbol reaches its own host mount deadline.
+ t.mock.timers.tick(100);
+
+ // Then only that symbol's actual row becomes visible.
+ assert.deepEqual(Array.from(host.document.querySelectorAll('[data-order-id]'), row => row.dataset.orderId), ['other-1']);
+ assert.deepEqual(host.fixture.snapshot().events.filter(({ type }) => type === 'order-rows-mounted').map(({ ids }) => ids),
+ [['other-1']]);
+});
+
+test('user can observe different native cancellation results for the actual requested row IDs', (t) => {
+ // Given one row has an unresolved cancellation while another row is confirmed normally.
+ const host = openNativeHost(t, createCancelScenario({
+ orders: mixedOrders, ui: { accountTab: 'openOrders' },
+ host: { rowCancelModesById: { 'current-1': 'unchanged' } },
+ }));
+ const clickRow = id => host.document.querySelector('[data-order-id="' + id + '"] svg')
+ .dispatchEvent(new host.document.defaultView.MouseEvent('click', { bubbles: true }));
+
+ // When the caller requests both concrete rows in order.
+ clickRow('current-1');
+ clickRow('other-1');
+ t.mock.timers.tick(1000);
+
+ // Then only the explicitly successful other-symbol request changes state and the unresolved row remains.
+ assert.deepEqual(host.fixture.snapshot().orders, [ORDER_SETS.current[0], ...protectedOrders]);
+ assert.deepEqual(host.fixture.snapshot().events.filter(({ type }) => type === 'row-cancel-cleared').map(({ orderId }) => orderId),
+ ['other-1']);
+ assert.deepEqual(host.fixture.snapshot().events.filter(({ type }) => type === 'row-cancel-requested').map(({ orderId }) => orderId),
+ ['current-1', 'other-1']);
+});
+
+for (const host of [
+ { orderRowsPageSize: 0 },
+ { orderRowsMountDelayMs: -1 },
+ { rowCancelModesById: { missing: 'clear' } },
+ { rowCancelModesById: { 'current-1': 'invent-success' } },
+]) {
+ test(`user cannot create an ambiguous paged native order fixture ${JSON.stringify(host)}`, () => {
+ // Given the declared host has invalid pagination, timing, or row-specific outcomes.
+ const scenario = { orders: mixedOrders, host };
+
+ // When a caller constructs the fixture from that declaration.
+ const construct = () => createCancelScenario(scenario);
+
+ // Then construction fails before any native DOM or account action occurs.
+ assert.throws(construct, /Native row/);
+ });
+}
+
+test('user receives native account count publications without losing the observed tab identities', (t) => {
+ // Given the account has no positions or orders and the close form has zero available quantities.
+ const host = openNativeHost(t, createCancelScenario({ ui: { tradeMode: 'CLOSE', accountTab: 'openOrders' } }));
+ const tabs = host.document.querySelector('#account-tabs');
+ const positionTab = tabs.querySelector('[data-account-tab="positions"]');
+ const ordersTab = tabs.querySelector('[data-account-tab="openOrders"]');
+ const position = { symbol: CURRENT_SYMBOL, side: 'SHORT', quantity: '4.5' };
+
+ // When independent native publications add a position and both kinds of orders.
+ host.fixture.setPositions([position]);
+ host.fixture.setOrders(mixedOrders);
+
+ // Then the existing observed elements carry the new counts and the form reflects the exact native quantity.
+ assert.equal(host.document.querySelector('#account-tabs'), tabs);
+ assert.equal(host.document.querySelector('[data-account-tab="positions"]'), positionTab);
+ assert.equal(host.document.querySelector('[data-account-tab="openOrders"]'), ordersTab);
+ assert.equal(positionTab.textContent, '仓位(1)');
+ assert.equal(ordersTab.textContent, '当前委托(4)');
+ assert.equal(host.document.querySelector('[data-open-orders-sub-tab="basic"]').textContent, '基础单(2)');
+ assert.equal(host.document.querySelector('[data-open-orders-sub-tab="conditional"]').textContent, '条件委托(2)');
+ assert.equal(host.document.querySelector('[data-testid="max-buy-amount"]').textContent, '可平 4.5 HYPE');
+ assert.deepEqual(host.fixture.snapshot().positions, [position]);
+ assert.deepEqual(host.fixture.snapshot().orders, mixedOrders);
+
+ // When a later native publication clears both account collections.
+ host.fixture.setPositions([]);
+ host.fixture.setOrders([]);
+
+ // Then the same counters return to zero and the obsolete native cancellation control disappears.
+ assert.equal(host.document.querySelector('#account-tabs'), tabs);
+ assert.equal(positionTab.textContent, '仓位(0)');
+ assert.equal(ordersTab.textContent, '当前委托(0)');
+ assert.equal(host.document.querySelector('[data-testid="max-buy-amount"]').textContent, '可平 0 HYPE');
+ assert.equal(host.document.querySelector('[data-cancel-all]'), null);
+ assert.deepEqual(host.fixture.snapshot().positions, []);
+ assert.deepEqual(host.fixture.snapshot().orders, []);
+});
+
+test('user receives a native order drawing only after acceptance and its full chart save after 100 milliseconds', async (t) => {
+ // Given the native chart contains one existing order and the new submit response is pending.
+ const host = openNativeHost(t, createCancelScenario({
+ orders: ORDER_SETS.current,
+ host: { orderDrawingEvents: true },
+ }));
+ const api = host.document.querySelector('.chart-widget-root iframe').contentWindow.tradingViewApi;
+ const drawings = [];
+ api.subscribe('drawing_event', (drawingId, eventType) => {
+ drawings.push({ drawingId, eventType, toolname: api.activeChart().getShapeById(drawingId).lineDataSource().toolname });
+ });
+ host.document.querySelector('.order-entry button').click();
+ assert.deepEqual(drawings, []);
+
+ // When the accepted response reaches the native caller and 99 milliseconds pass.
+ await host.respond({ success: true });
+ t.mock.timers.tick(99);
+
+ // Then the real native shape API identifies the order while persistence still waits for its deadline.
+ assert.deepEqual(drawings, [{ drawingId: 'order-submitted-1', eventType: 'create', toolname: 'LineToolOrder' }]);
+ assert.deepEqual(host.fixture.snapshot().events.filter(({ type }) => type === 'chart-save-requested'), []);
+ assert.deepEqual(host.fixture.snapshot().events.filter(({ type }) => type === 'chart-saved'), []);
+
+ // When the complete native serialization delay elapses.
+ t.mock.timers.tick(1);
+
+ // Then exactly one native save contains both original and accepted order drawings.
+ const events = host.fixture.snapshot().events;
+ const snapshot = { checked: true, drawingIds: ['order-current-1', 'order-submitted-1'] };
+ assert.deepEqual(events.filter(({ type }) => type === 'chart-save-requested').map(({ drawingId, eventType, snapshot }) => ({ drawingId, eventType, snapshot })),
+ [{ drawingId: 'order-submitted-1', eventType: 'create', snapshot }]);
+ assert.deepEqual(events.filter(({ type }) => type === 'chart-saved').map(({ snapshot }) => snapshot), [snapshot]);
+});
+
+for (const [outcome, payload] of [
+ ['rejected', { success: false, code: '90800001', message: 'Fixture rejection' }],
+ ['unknown', { result: 'unrecognized' }],
+]) {
+ test(`user receives no native order drawing from ${outcome} submission results`, async (t) => {
+ // Given native chart event modeling is enabled for a pending submit.
+ const host = openNativeHost(t, createCancelScenario({ host: { orderDrawingEvents: true } }));
+ host.document.querySelector('.order-entry button').click();
+
+ // When the explicit non-success payload arrives and every chart deadline passes.
+ await host.respond(payload);
+ t.mock.timers.tick(1_000);
+
+ // Then neither an order shape nor chart persistence is fabricated.
+ assert.deepEqual(host.fixture.snapshot().events.filter(({ type }) => type.startsWith('chart-')), []);
+ const api = host.document.querySelector('.chart-widget-root iframe').contentWindow.tradingViewApi;
+ assert.throws(() => api.activeChart().getShapeById('order-submitted-1'), /No native chart order drawing exists/);
+ });
+}
+
+for (const changed of ['symbol', 'visibility']) {
+ test(`user receives no off-chart order drawing when ${changed} changes before acceptance`, async (t) => {
+ // Given the native request belongs to the original visible chart context.
+ const host = openNativeHost(t, createCancelScenario({
+ host: { orderDrawingEvents: true },
+ }));
+ host.document.querySelector('.order-entry button').click();
+
+ // When a late successful response belongs to an unavailable order-drawing context.
+ if (changed === 'symbol') host.fixture.switchSymbol(OTHER_SYMBOL);
+ else host.document.querySelector('[data-chart-orders-checkbox]').click();
+ await host.respond({ success: true });
+ t.mock.timers.tick(1_000);
+
+ // Then the API success stays visible without drawing an order into the wrong chart.
+ assert.equal(host.fixture.snapshot().events.filter(({ type }) => type === 'order-submit-api-success').length, 1);
+ assert.deepEqual(host.fixture.snapshot().events.filter(({ type }) => [
+ 'chart-drawing-event', 'chart-save-requested', 'chart-saved',
+ ].includes(type)), []);
+ });
+}
+
+test('user receives native drawing removals only for the clicked visible-chart order and can unsubscribe from later events', async (t) => {
+ // Given both symbols have native orders while only the current-symbol drawing belongs to this chart.
+ const host = openNativeHost(t, createCancelScenario({
+ orders: ORDER_SETS.both,
+ ui: { accountTab: 'openOrders' },
+ host: { orderDrawingEvents: true },
+ }));
+ const api = host.document.querySelector('.chart-widget-root iframe').contentWindow.tradingViewApi;
+ const drawings = [];
+ const listener = (drawingId, eventType) => drawings.push({ drawingId, eventType });
+ api.subscribe('drawing_event', listener);
+
+ // When native row actions cancel both IDs and their chart serialization delay completes.
+ host.document.querySelector('[data-order-id="current-1"] svg')
+ .dispatchEvent(new host.document.defaultView.MouseEvent('click', { bubbles: true }));
+ host.document.querySelector('[data-order-id="other-1"] svg')
+ .dispatchEvent(new host.document.defaultView.MouseEvent('click', { bubbles: true }));
+ t.mock.timers.tick(0);
+ t.mock.timers.tick(100);
+
+ // Then only the actual current chart drawing emits removal and its final save is empty.
+ assert.deepEqual(drawings, [{ drawingId: 'order-current-1', eventType: 'remove' }]);
+ assert.deepEqual(host.fixture.snapshot().events.filter(({ type }) => type === 'chart-saved').map(({ snapshot }) => snapshot),
+ [{ checked: true, drawingIds: [] }]);
+ assert.deepEqual(host.fixture.snapshot().orders, []);
+ assert.throws(() => api.activeChart().getShapeById('order-current-1'), /No native chart order drawing exists/);
+
+ // When the listener unsubscribes before a later accepted native submission.
+ api.unsubscribe('drawing_event', listener);
+ host.document.querySelector('.order-entry button').click();
+ await host.respond({ success: true });
+ t.mock.timers.tick(100);
+
+ // Then the native chart still saves, but the removed subscriber cannot receive the create event.
+ assert.deepEqual(drawings, [{ drawingId: 'order-current-1', eventType: 'remove' }]);
+ assert.deepEqual(host.fixture.snapshot().events.filter(({ type }) => type === 'chart-saved').map(({ snapshot }) => snapshot), [
+ { checked: true, drawingIds: [] },
+ { checked: true, drawingIds: ['order-submitted-1'] },
+ ]);
+});
+
+for (const enabled of [null, 'true', 1]) {
+ test(`user cannot configure native drawing events with the ambiguous value ${JSON.stringify(enabled)}`, () => {
+ // Given the host option contains an unsupported non-boolean value.
+ const scenario = { host: { orderDrawingEvents: enabled } };
+
+ // When the caller attempts to construct that native scenario.
+ const construct = () => createCancelScenario(scenario);
+
+ // Then the explicit drawing-mode contract rejects the value before any page can load.
+ assert.throws(construct, /Native order drawing events must be explicitly enabled or disabled/);
+ });
+}
diff --git a/test/unit/binance-live-capture-builder.test.js b/test/unit/binance-live-capture-builder.test.js
index ffedae2..94836ac 100644
--- a/test/unit/binance-live-capture-builder.test.js
+++ b/test/unit/binance-live-capture-builder.test.js
@@ -45,15 +45,19 @@ function dialogEvents(primary) {
];
}
-test('builds a no-orders sample directly from one probe snapshot', () => {
- const sample = buildLivePerformanceSample({
+test('user builds a no-orders sample directly from one probe snapshot', () => {
+ // Given the supplied input describes this data scenario
+ const scenarioInput = {
parameters: { kind: 'no-orders' },
probe: probeSnapshot([{ kind: 'first-feedback', atMs: 3, detail: null }]),
capacityEvidence: null,
testOrderLedger: EMPTY_LEDGER,
stateRestored: true,
- });
+ };
+ // When the builds a no-orders sample directly from one probe snapshot
+ const sample = buildLivePerformanceSample(scenarioInput);
+ // Then builds a no-orders sample directly from one probe snapshot
assert.deepEqual(sample.segmentsMs, {
clickToFirstFeedback: 3,
clickToFinalReady: 200,
@@ -63,14 +67,18 @@ test('builds a no-orders sample directly from one probe snapshot', () => {
assert.equal(sample.uncaughtErrors, 0);
});
-test('derives cancel and confirm decision timing from semantic probe events', () => {
- const cancel = buildLivePerformanceSample({
+test('user derives cancel and confirm decision timing from semantic probe events', () => {
+ // Given the supplied input describes this data scenario
+ const scenarioInput = {
parameters: { kind: 'dialog-cancel', testOrderCount: 1 },
probe: probeSnapshot(dialogEvents(false)),
capacityEvidence: {},
testOrderLedger: { created: [{}], fills: [], residual: [] },
stateRestored: true,
- });
+ };
+ // When the derives cancel and confirm decision timing from semantic probe events
+ const cancel = buildLivePerformanceSample(scenarioInput);
+ // Then derives cancel and confirm decision timing from semantic probe events
assert.deepEqual(cancel.segmentsMs, {
clickToFirstFeedback: 4,
clickToDialog: 80,
@@ -87,22 +95,33 @@ test('derives cancel and confirm decision timing from semantic probe events', ()
assert.deepEqual(confirm.segmentsMs, cancel.segmentsMs);
});
-test('rejects a dialog outcome that contradicts the declared scenario kind', () => {
- assert.throws(
- () => buildLivePerformanceSample({
+test('user rejects a dialog outcome that contradicts the declared scenario kind', () => {
+ // Given the rejected input preserves the specific invalid condition
+ const scenarioInput = {
parameters: { kind: 'dialog-confirm', testOrderCount: 1 },
probe: probeSnapshot(dialogEvents(false)),
capacityEvidence: {},
testOrderLedger: { created: [{}], fills: [], residual: [] },
stateRestored: true,
- }),
- /requires the primary dialog action/,
- );
+ };
+ let failure;
+ // When the real operation evaluates the rejected input
+ try {
+ buildLivePerformanceSample(scenarioInput);
+ } catch (error) {
+ failure = error;
+ }
+ // Then rejects a dialog outcome that contradicts the declared scenario kind
+ assert.ok(failure instanceof Error);
+ assert.match(failure.message, /requires the primary dialog action/);
});
-test('rejects a dialog that closes before the recorded user decision', () => {
+test('user rejects a dialog that closes before the recorded user decision', () => {
+ // Given the probe fixture contains timing events and scenario evidence
const events = dialogEvents(true);
+ // When the capture builder processes the supplied probe evidence
events.find((event) => event.kind === 'dialog-hidden').atMs = 140;
+ // Then rejects a dialog that closes before the recorded user decision
assert.throws(
() => buildLivePerformanceSample({
parameters: { kind: 'dialog-confirm', testOrderCount: 1 },
@@ -115,8 +134,9 @@ test('rejects a dialog that closes before the recorded user decision', () => {
);
});
-test('builds and validates a complete three-sample capture without manual timing transcription', () => {
- const capture = buildLivePerformanceCapture({
+test('user builds and validates a complete three-sample capture without manual timing transcription', () => {
+ // Given the supplied input describes this data scenario
+ const scenarioInput = {
capturedAt: '2026-08-27T01:00:00.000Z',
environment: {
browser: 'Chrome 151.0.0.0',
@@ -136,8 +156,11 @@ test('builds and validates a complete three-sample capture without manual timing
stateRestored: true,
})),
}],
- });
+ };
+ // When the builds and validates a complete three-sample capture without manual timing transcription
+ const capture = buildLivePerformanceCapture(scenarioInput);
+ // Then builds and validates a complete three-sample capture without manual timing transcription
assert.equal(capture.scenarios[0].samples.length, 3);
assert.deepEqual(capture.scenarios[0].applicableSegments, [
'clickToFirstFeedback',
@@ -145,14 +168,22 @@ test('builds and validates a complete three-sample capture without manual timing
]);
});
-test('rejects unknown raw-bundle fields instead of silently dropping them', () => {
- assert.throws(
- () => buildLivePerformanceCapture({
+test('user rejects unknown raw-bundle fields instead of silently dropping them', () => {
+ // Given the rejected input preserves the specific invalid condition
+ const scenarioInput = {
capturedAt: '2026-08-27T01:00:00.000Z',
environment: {},
scenarios: [],
ignored: true,
- }),
- /input keys must be exactly/,
- );
+ };
+ let failure;
+ // When the real operation evaluates the rejected input
+ try {
+ buildLivePerformanceCapture(scenarioInput);
+ } catch (error) {
+ failure = error;
+ }
+ // Then rejects unknown raw-bundle fields instead of silently dropping them
+ assert.ok(failure instanceof Error);
+ assert.match(failure.message, /input keys must be exactly/);
});
diff --git a/test/unit/binance-live-capture-cli.test.js b/test/unit/binance-live-capture-cli.test.js
index 040d5e3..6b8de04 100644
--- a/test/unit/binance-live-capture-cli.test.js
+++ b/test/unit/binance-live-capture-cli.test.js
@@ -58,7 +58,8 @@ function rawBundle() {
};
}
-test('CLI assembles a strict capture file from a raw probe bundle', async (context) => {
+test('user assembles a strict capture file from a raw probe bundle', async (context) => {
+ // Given the local capture fixture contains a raw probe bundle
const directory = await mkdtemp(join(tmpdir(), 'binance-live-capture-'));
context.after(() => rm(directory, { recursive: true, force: true }));
const inputPath = join(directory, 'raw-bundle.json');
@@ -66,8 +67,10 @@ test('CLI assembles a strict capture file from a raw probe bundle', async (conte
await writeFile(inputPath, `${JSON.stringify(rawBundle(), null, 2)}\n`);
const result = await runLiveCaptureAssemblyCli([inputPath, outputPath]);
+ // When the assembly CLI processes the supplied paths
const capture = JSON.parse(await readFile(outputPath, 'utf8'));
+ // Then CLI assembles a strict capture file from a raw probe bundle
assert.equal(result.outputPath, outputPath);
assert.equal(result.scenarioCount, 1);
assert.equal(result.sampleCount, 3);
@@ -77,23 +80,31 @@ test('CLI assembles a strict capture file from a raw probe bundle', async (conte
});
});
-test('CLI refuses to overwrite its raw input bundle', async () => {
+test('user refuses to overwrite its raw input bundle', async () => {
+ // Given the supplied input retains its original contract values
+ const scenarioInput = ['/tmp/live-bundle.json', '/tmp/live-bundle.json'];
+ // When the real operation processes that input
+ const observed = runLiveCaptureAssemblyCli(scenarioInput);
+ // Then CLI refuses to overwrite its raw input bundle
await assert.rejects(
- runLiveCaptureAssemblyCli(['/tmp/live-bundle.json', '/tmp/live-bundle.json']),
+ observed,
/input and output paths must differ/,
);
});
-test('CLI preserves an existing capture instead of overwriting evidence', async (context) => {
+test('user preserves an existing capture instead of overwriting evidence', async (context) => {
+ // Given the local capture fixture contains a raw probe bundle
const directory = await mkdtemp(join(tmpdir(), 'binance-live-capture-existing-'));
context.after(() => rm(directory, { recursive: true, force: true }));
const inputPath = join(directory, 'raw-bundle.json');
const outputPath = join(directory, 'capture.json');
+ // When the assembly CLI processes the supplied paths
await Promise.all([
writeFile(inputPath, `${JSON.stringify(rawBundle(), null, 2)}\n`),
writeFile(outputPath, 'existing evidence\n'),
]);
+ // Then CLI preserves an existing capture instead of overwriting evidence
await assert.rejects(
runLiveCaptureAssemblyCli([inputPath, outputPath]),
(error) => error.code === 'EEXIST',
diff --git a/test/unit/binance-live-order-scale-config.test.js b/test/unit/binance-live-order-scale-config.test.js
index cd83350..f8e3394 100644
--- a/test/unit/binance-live-order-scale-config.test.js
+++ b/test/unit/binance-live-order-scale-config.test.js
@@ -27,8 +27,13 @@ function liveContext(overrides = {}) {
};
}
-test('smoke profile derives three internal scales from live capacity', () => {
- assert.equal(validateLiveOrderScaleProfile(profile).profileName, 'smoke');
+test('user observes that smoke profile derives three internal scales from live capacity', () => {
+ // Given the supplied input retains its original contract values
+ const scenarioInput = profile;
+ // When the real operation processes that input
+ const observed = validateLiveOrderScaleProfile(scenarioInput).profileName;
+ // Then smoke profile derives three internal scales from live capacity
+ assert.equal(observed, 'smoke');
const plan = createLiveOrderScalePlan(profile, liveContext());
assert.equal(plan.effectiveCapacity, 3);
@@ -42,23 +47,39 @@ test('smoke profile derives three internal scales from live capacity', () => {
assert.equal(plan.capacityEvidence.maxNewOrdersByMargin, 10);
});
-test('scale counts are configuration-driven rather than fixed to smoke values', () => {
- const plan = createLiveOrderScalePlan({ ...profile, maxOrderCount: 40 }, liveContext({
+test('user observes that scale counts are configuration-driven rather than fixed to smoke values', () => {
+ // Given the supplied input describes this data scenario
+ const scenarioInput = { ...profile, maxOrderCount: 40 };
+ // When the scale counts are configuration-driven rather than fixed to smoke values
+ const plan = createLiveOrderScalePlan(scenarioInput, liveContext({
testBudget: '100',
}));
+ // Then scale counts are configuration-driven rather than fixed to smoke values
assert.deepEqual(plan.scales.map((scale) => scale.effectiveTargetOrderCount), [10, 20, 40]);
});
-test('insufficient live capacity fails instead of silently collapsing scale labels', () => {
- assert.throws(
- () => createLiveOrderScalePlan(profile, liveContext({ testBudget: '0.4' })),
- /cannot form three distinct scales/,
- );
+test('user observes that insufficient live capacity fails instead of silently collapsing scale labels', () => {
+ // Given the rejected input preserves the specific invalid condition
+ const scenarioInput = liveContext({ testBudget: '0.4' });
+ let failure;
+ // When the real operation evaluates the rejected input
+ try {
+ createLiveOrderScalePlan(profile, scenarioInput);
+ } catch (error) {
+ failure = error;
+ }
+ // Then insufficient live capacity fails instead of silently collapsing scale labels
+ assert.ok(failure instanceof Error);
+ assert.match(failure.message, /cannot form three distinct scales/);
});
-test('capacity evidence validates actual notional and slot arithmetic', () => {
- const evidence = createLiveOrderScalePlan(profile, liveContext()).capacityEvidence;
+test('user observes that capacity evidence validates actual notional and slot arithmetic', () => {
+ // Given the supplied input describes this data scenario
+ const scenarioInput = profile;
+ // When the capacity evidence validates actual notional and slot arithmetic
+ const evidence = createLiveOrderScalePlan(scenarioInput, liveContext()).capacityEvidence;
+ // Then capacity evidence validates actual notional and slot arithmetic
assert.equal(validateLiveOrderCapacityEvidence(evidence).perOrderNotional, '5');
assert.throws(
() => validateLiveOrderCapacityEvidence({ ...evidence, perOrderNotional: '4.9' }),
@@ -66,14 +87,18 @@ test('capacity evidence validates actual notional and slot arithmetic', () => {
);
});
-test('one-order smoke capacity is valid without requiring three scale levels', () => {
- const evidence = createLiveOrderCapacityEvidence(liveContext({
+test('user observes that one-order smoke capacity is valid without requiring three scale levels', () => {
+ // Given the supplied input describes this data scenario
+ const scenarioInput = liveContext({
testBudget: '1.25',
currentLeverage: 1,
perOrderPrice: '1',
perOrderQuantity: '1',
- }));
+ });
+ // When the one-order smoke capacity is valid without requiring three scale levels
+ const evidence = createLiveOrderCapacityEvidence(scenarioInput);
+ // Then one-order smoke capacity is valid without requiring three scale levels
assert.equal(evidence.maxNewOrdersByMargin, 1);
assert.equal(validateLiveOrderCapacityEvidence(evidence), evidence);
assert.throws(
@@ -87,20 +112,32 @@ test('one-order smoke capacity is valid without requiring three scale levels', (
);
});
-test('live order slots subtract existing and outstanding test-owned orders', () => {
- const plan = createLiveOrderScalePlan(profile, liveContext({
+test('user observes that live order slots subtract existing and outstanding test-owned orders', () => {
+ // Given the supplied input describes this data scenario
+ const scenarioInput = profile;
+ // When the live order slots subtract existing and outstanding test-owned orders
+ const plan = createLiveOrderScalePlan(scenarioInput, liveContext({
liveMaxNumOrdersLimit: 8,
existingCurrentSymbolOpenOrders: 2,
outstandingTestOwnedOrders: 1,
}));
+ // Then live order slots subtract existing and outstanding test-owned orders
assert.equal(plan.capacityEvidence.maxNewOrdersBySlots, 4);
assert.equal(plan.effectiveCapacity, 3);
});
-test('zero leverage fails instead of inventing test capacity', () => {
- assert.throws(
- () => createLiveOrderScalePlan(profile, liveContext({ currentLeverage: 0 })),
- /currentLeverage must be positive/,
- );
+test('user observes that zero leverage fails instead of inventing test capacity', () => {
+ // Given the rejected input preserves the specific invalid condition
+ const scenarioInput = liveContext({ currentLeverage: 0 });
+ let failure;
+ // When the real operation evaluates the rejected input
+ try {
+ createLiveOrderScalePlan(profile, scenarioInput);
+ } catch (error) {
+ failure = error;
+ }
+ // Then zero leverage fails instead of inventing test capacity
+ assert.ok(failure instanceof Error);
+ assert.match(failure.message, /currentLeverage must be positive/);
});
diff --git a/test/unit/binance-live-performance-probe.test.js b/test/unit/binance-live-performance-probe.test.js
index 92e5ca5..ebe1bed 100644
--- a/test/unit/binance-live-performance-probe.test.js
+++ b/test/unit/binance-live-performance-probe.test.js
@@ -34,8 +34,13 @@ function snapshot(overrides = {}) {
};
}
-test('live probe snapshot requires complete supported performance evidence', () => {
- assert.equal(validateLivePerformanceProbeSnapshot(snapshot()).schemaVersion, 1);
+test('user observes that live probe snapshot requires complete supported performance evidence', () => {
+ // Given the supplied input retains its original contract values
+ const scenarioInput = snapshot();
+ // When the real operation processes that input
+ const observed = validateLivePerformanceProbeSnapshot(scenarioInput).schemaVersion;
+ // Then live probe snapshot requires complete supported performance evidence
+ assert.equal(observed, 1);
assert.throws(
() => validateLivePerformanceProbeSnapshot(snapshot({
performanceSupport: { longTask: false, longAnimationFrame: true },
@@ -54,42 +59,66 @@ test('live probe snapshot requires complete supported performance evidence', ()
);
});
-test('live probe snapshot rejects every bounded-buffer overflow', () => {
- for (const stream of ['events', 'errors', 'longTasks', 'longAnimationFrames']) {
+test('user observes that live probe snapshot rejects every bounded-buffer overflow', () => {
+ // Given each bounded evidence stream has a snapshot with one dropped entry
+ const streams = ['events', 'errors', 'longTasks', 'longAnimationFrames'];
+ const snapshots = streams.map(stream => {
const dropped = { events: 0, errors: 0, longTasks: 0, longAnimationFrames: 0 };
dropped[stream] = 1;
- assert.throws(
- () => validateLivePerformanceProbeSnapshot(snapshot({ dropped })),
- new RegExp(`${stream} overflowed`),
- );
+ return snapshot({ dropped });
+ });
+ // When each incomplete snapshot is validated
+ const failures = snapshots.map(value => {
+ try {
+ validateLivePerformanceProbeSnapshot(value);
+ return null;
+ } catch (error) {
+ return error;
+ }
+ });
+ // Then every rejection identifies the stream that lost evidence
+ for (const [index, stream] of streams.entries()) {
+ assert.ok(failures[index] instanceof Error);
+ assert.match(failures[index].message, new RegExp(`${stream} overflowed`));
}
});
-test('live probe Runtime.evaluate expression is self-contained', () => {
- const expression = createLivePerformanceProbeExpression({ eventLimit: 25 });
+test('user observes that live probe Runtime.evaluate expression is self-contained', () => {
+ // Given the supplied input describes this data scenario
+ const scenarioInput = { eventLimit: 25 };
+ // When the live probe Runtime.evaluate expression is self-contained
+ const expression = createLivePerformanceProbeExpression(scenarioInput);
+ // Then live probe Runtime.evaluate expression is self-contained
assert.match(expression, /^\(function installBinanceLivePerformanceProbe/);
assert.match(expression, /"eventLimit":25/);
assert.doesNotMatch(expression, /DEFAULT_GLOBAL_NAME/);
});
-test('live completion preparation and result expressions remove the action race', () => {
+test('user observes that live completion preparation and result expressions remove the action race', () => {
+ // Given the live probe fixture contains performance support and bounded buffers
const preparation = createLivePerformanceCompletionPreparationExpression({
kind: 'no-orders',
});
+ // When the probe contract evaluates the supplied snapshot
const result = createLivePerformanceCompletionResultExpression();
+ // Then live completion preparation and result expressions remove the action race
assert.match(preparation, /window\[completionGlobalName\] = \(function waitForBinanceLivePerformanceCompletion/);
assert.match(preparation, /prepared: true/);
assert.match(result, /return await completion/);
assert.match(result, /delete window\[completionGlobalName\]/);
});
-test('live completion Runtime.evaluate expression owns the page-ready contract', () => {
- const expression = createLivePerformanceCompletionExpression({
+test('user observes that live completion Runtime.evaluate expression owns the page-ready contract', () => {
+ // Given the supplied input describes this data scenario
+ const scenarioInput = {
kind: 'dialog-confirm',
- });
+ };
+ // When the live completion Runtime.evaluate expression owns the page-ready contract
+ const expression = createLivePerformanceCompletionExpression(scenarioInput);
+ // Then live completion Runtime.evaluate expression owns the page-ready contract
assert.match(expression, /^\(function waitForBinanceLivePerformanceCompletion/);
assert.match(expression, /"kind":"dialog-confirm"/);
assert.match(expression, /finishAfterPerformanceTail/);
diff --git a/test/unit/binance-live-performance.test.js b/test/unit/binance-live-performance.test.js
index 7c9843a..f43e885 100644
--- a/test/unit/binance-live-performance.test.js
+++ b/test/unit/binance-live-performance.test.js
@@ -116,34 +116,41 @@ function scaleCapture() {
return result;
}
-test('live performance capture requires three complete isolated samples', () => {
- assert.equal(validateLivePerformanceCapture(capture()).schemaVersion, 1);
+test('user observes that live performance capture requires three complete isolated samples', () => {
+ // Given the supplied input retains its original contract values
+ const scenarioInput = capture();
+ // When the real operation processes that input
+ const observed = validateLivePerformanceCapture(scenarioInput).schemaVersion;
+ // Then live performance capture requires three complete isolated samples
+ assert.equal(observed, 1);
assert.throws(
() => validateLivePerformanceCapture(capture([sample(90, 150, 140), sample(100, 160, 150)])),
/at least three isolated samples/,
);
});
-test('scenario kind fixes the exact wall-clock segment contract', () => {
+test('user observes that scenario kind fixes the exact wall-clock segment contract', () => {
+ // Given the capture fixture contains measured segments and cleanup evidence
const invalid = capture();
invalid.scenarios[0].applicableSegments = ['clickToFirstFeedback', 'decisionToFinalReady'];
+ // When the performance contract processes the supplied capture
for (const entry of invalid.scenarios[0].samples) {
delete entry.segmentsMs.clickToDialog;
}
+ // Then scenario kind fixes the exact wall-clock segment contract
assert.throws(
() => validateLivePerformanceCapture(invalid),
/applicableSegments must match the dialog-cancel contract/,
);
});
-test('live performance capture models no-orders, dialog-cancel, and dialog-confirm explicitly', () => {
+test('user observes that live performance capture models no-orders, dialog-cancel, and dialog-confirm explicitly', () => {
+ // Given captures describe all three supported dialog outcomes
const dialogCancel = capture();
- assert.equal(validateLivePerformanceCapture(dialogCancel).scenarios[0].parameters.kind, 'dialog-cancel');
const dialogConfirm = structuredClone(dialogCancel);
dialogConfirm.scenarios[0].name = 'cancel-dialog-confirm';
dialogConfirm.scenarios[0].parameters.kind = 'dialog-confirm';
- assert.equal(validateLivePerformanceCapture(dialogConfirm).scenarios[0].parameters.kind, 'dialog-confirm');
const noOrders = structuredClone(dialogCancel);
noOrders.scenarios[0].name = 'cancel-current-symbol-no-orders';
@@ -160,12 +167,18 @@ test('live performance capture models no-orders, dialog-cancel, and dialog-confi
clickToFinalReady: entry.segmentsMs.decisionToFinalReady,
};
}
- assert.equal(validateLivePerformanceCapture(noOrders).scenarios[0].parameters.kind, 'no-orders');
+ // When all three complete evidence records are validated
+ const kinds = [dialogCancel, dialogConfirm, noOrders].map(value => validateLivePerformanceCapture(value).scenarios[0].parameters.kind);
+ // Then each recorded outcome remains distinct in the validated capture
+ assert.deepEqual(kinds, ['dialog-cancel', 'dialog-confirm', 'no-orders']);
});
-test('dialog captures bind the declared test-order count to capacity and ledger evidence', () => {
+test('user observes that dialog captures bind the declared test-order count to capacity and ledger evidence', () => {
+ // Given the capture fixture contains measured segments and cleanup evidence
const missingOrder = capture();
+ // When the performance contract processes the supplied capture
missingOrder.scenarios[0].samples[0].testOrderLedger.created = [];
+ // Then dialog captures bind the declared test-order count to capacity and ledger evidence
assert.throws(
() => validateLivePerformanceCapture(missingOrder),
/created ledger count must match the declared test order count/,
@@ -182,9 +195,12 @@ test('dialog captures bind the declared test-order count to capacity and ledger
);
});
-test('live performance capture rejects missing segments and failed cleanup invariants', () => {
+test('user observes that live performance capture rejects missing segments and failed cleanup invariants', () => {
+ // Given the capture fixture contains measured segments and cleanup evidence
const missingSegment = capture();
+ // When the performance contract processes the supplied capture
delete missingSegment.scenarios[0].samples[0].segmentsMs.clickToDialog;
+ // Then live performance capture rejects missing segments and failed cleanup invariants
assert.throws(() => validateLivePerformanceCapture(missingSegment), /keys must be exactly/);
const residualOrder = capture();
@@ -192,7 +208,8 @@ test('live performance capture rejects missing segments and failed cleanup invar
assert.throws(() => validateLivePerformanceCapture(residualOrder), /must match testOrderLedger.residual/);
});
-test('live performance capture requires fill and residual claims to be backed by the test-order ledger', () => {
+test('user observes that live performance capture requires fill and residual claims to be backed by the test-order ledger', () => {
+ // Given the capture fixture contains measured segments and cleanup evidence
const order = {
symbol: 'HYPEUSDT',
side: 'SELL',
@@ -202,7 +219,9 @@ test('live performance capture requires fill and residual claims to be backed by
createdAt: '2026-08-26T08:00:01.000Z',
};
const unsupportedFill = scaleCapture();
+ // When the performance contract processes the supplied capture
unsupportedFill.scenarios[0].samples[0].testOrderLedger.fills.push(order);
+ // Then live performance capture requires fill and residual claims to be backed by the test-order ledger
assert.throws(
() => validateLivePerformanceCapture(unsupportedFill),
/fills must reference a created test order/,
@@ -218,8 +237,13 @@ test('live performance capture requires fill and residual claims to be backed by
);
});
-test('order-scale capture binds effective target to capacity evidence and created ledger', () => {
- assert.equal(validateLivePerformanceCapture(scaleCapture()).schemaVersion, 1);
+test('user observes that order-scale capture binds effective target to capacity evidence and created ledger', () => {
+ // Given the supplied input retains its original contract values
+ const scenarioInput = scaleCapture();
+ // When the real operation processes that input
+ const observed = validateLivePerformanceCapture(scenarioInput).schemaVersion;
+ // Then order-scale capture binds effective target to capacity evidence and created ledger
+ assert.equal(observed, 1);
const mismatchedCount = scaleCapture();
mismatchedCount.scenarios[0].parameters.preferredTargetOrderCount = 2;
mismatchedCount.scenarios[0].parameters.effectiveTargetOrderCount = 2;
@@ -229,10 +253,13 @@ test('order-scale capture binds effective target to capacity evidence and create
);
});
-test('live performance summary calculates median and nearest-rank p95', () => {
+test('user observes that live performance summary calculates median and nearest-rank p95', () => {
+ // Given the capture fixture contains measured segments and cleanup evidence
const summary = summarizeLivePerformanceCapture(capture());
+ // When the performance contract processes the supplied capture
const scenario = summary.scenarios[0];
+ // Then live performance summary calculates median and nearest-rank p95
assert.equal(scenario.sampleCount, 3);
assert.deepEqual(scenario.segmentsMs.clickToFirstFeedback, {
min: 90,
@@ -248,18 +275,21 @@ test('live performance summary calculates median and nearest-rank p95', () => {
});
});
-test('baseline comparison reports only regressions beyond both tolerances', () => {
+test('user observes that baseline comparison reports only regressions beyond both tolerances', () => {
+ // Given the capture fixture contains measured segments and cleanup evidence
const baseline = summarizeLivePerformanceCapture(capture());
const current = structuredClone(baseline);
current.scenarios[0].segmentsMs.clickToDialog.median = 260;
current.scenarios[0].segmentsMs.clickToDialog.p95 = 400;
current.scenarios[0].segmentsMs.clickToDialog.max = 400;
+ // When the performance contract processes the supplied capture
const findings = compareLivePerformanceSummaries(current, baseline, {
absoluteToleranceMs: 50,
medianRatio: 1.5,
p95Ratio: 1.5,
});
+ // Then baseline comparison reports only regressions beyond both tolerances
assert.deepEqual(findings, [
{
scenario: 'cancel-dialog-cancel',
@@ -280,9 +310,11 @@ test('baseline comparison reports only regressions beyond both tolerances', () =
]);
});
-test('baseline comparison rejects the same scale name with different effective counts', () => {
+test('user observes that baseline comparison rejects the same scale name with different effective counts', () => {
+ // Given the capture fixture contains measured segments and cleanup evidence
const baseline = summarizeLivePerformanceCapture(capture());
const current = structuredClone(baseline);
+ // When the performance contract processes the supplied capture
current.scenarios[0].parameters = {
kind: 'order-scale',
profileName: 'smoke',
@@ -292,6 +324,7 @@ test('baseline comparison rejects the same scale name with different effective c
sampleCount: 3,
};
+ // Then baseline comparison rejects the same scale name with different effective counts
assert.deepEqual(
compareLivePerformanceSummaries(current, baseline, {
absoluteToleranceMs: 50,
@@ -308,14 +341,17 @@ test('baseline comparison rejects the same scale name with different effective c
);
});
-test('baseline validation rejects missing summary statistics instead of silently passing comparison', () => {
+test('user observes that baseline validation rejects missing summary statistics instead of silently passing comparison', () => {
+ // Given the capture fixture contains measured segments and cleanup evidence
const summary = summarizeLivePerformanceCapture(capture());
const baseline = {
...structuredClone(summary),
comparisonPolicy: { absoluteToleranceMs: 50, medianRatio: 1.5, p95Ratio: 1.5 },
};
+ // When the performance contract processes the supplied capture
delete baseline.scenarios[0].segmentsMs.clickToDialog.median;
+ // Then baseline validation rejects missing summary statistics instead of silently passing comparison
assert.throws(() => validateLivePerformanceBaseline(baseline), /keys must be exactly/);
assert.throws(
() => compareLivePerformanceSummaries(summary, baseline, baseline.comparisonPolicy),
@@ -323,13 +359,16 @@ test('baseline validation rejects missing summary statistics instead of silently
);
});
-test('baseline comparison reports a baseline scenario omitted from the current capture', () => {
+test('user observes that baseline comparison reports a baseline scenario omitted from the current capture', () => {
+ // Given the capture fixture contains measured segments and cleanup evidence
const baseline = summarizeLivePerformanceCapture(capture());
const missingScenario = structuredClone(baseline.scenarios[0]);
missingScenario.name = 'cancel-dialog-confirm';
baseline.scenarios.push(missingScenario);
+ // When the performance contract processes the supplied capture
const current = summarizeLivePerformanceCapture(capture());
+ // Then baseline comparison reports a baseline scenario omitted from the current capture
assert.deepEqual(
compareLivePerformanceSummaries(current, baseline, {
absoluteToleranceMs: 50,
@@ -340,7 +379,8 @@ test('baseline comparison reports a baseline scenario omitted from the current c
);
});
-test('CLI compare and enforce use the documented baseline root shape', async (context) => {
+test('user compare and enforce use the documented baseline root shape', async (context) => {
+ // Given the capture fixture contains measured segments and cleanup evidence
const directory = await mkdtemp(join(tmpdir(), 'binance-live-performance-'));
context.after(() => rm(directory, { recursive: true, force: true }));
const capturePath = join(directory, 'capture.json');
@@ -354,7 +394,9 @@ test('CLI compare and enforce use the documented baseline root shape', async (co
await writeFile(capturePath, JSON.stringify(liveCapture));
await writeFile(baselinePath, JSON.stringify(baseline));
+ // When the performance contract processes the supplied capture
const passing = await runLivePerformanceCli([capturePath, '--compare', baselinePath, '--enforce']);
+ // Then CLI compare and enforce use the documented baseline root shape
assert.deepEqual(passing.findings, []);
liveCapture.scenarios[0].samples = [
diff --git a/test/unit/binance-order-entry-host-boundaries.test.js b/test/unit/binance-order-entry-host-boundaries.test.js
new file mode 100644
index 0000000..4af61e1
--- /dev/null
+++ b/test/unit/binance-order-entry-host-boundaries.test.js
@@ -0,0 +1,150 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { JSDOM } from 'jsdom';
+import {
+ installNativeCloseQuantityTransition,
+ installNativePostOnlyTransition,
+ installOrderEntryReadProbe,
+} from '../helpers/order-entry-host-boundaries.js';
+
+const html = `
+
81.0
+
+
开仓
平仓
+
只做Maker
+
可开 10 HYPE
可开 10 HYPE
+
+
Original panel
+
+`;
+
+function openHost(t) {
+ const dom = new JSDOM(html);
+ t.after(() => dom.window.close());
+ return dom.window;
+}
+
+test('user receives a native Post Only selection only after its requested transition commits', t => {
+ // Given the native order type is Limit and no selection request is pending.
+ const view = openHost(t);
+ const host = installNativePostOnlyTransition({ ownerDocument: view.document });
+ assert.deepEqual(host.snapshot(), { requests: 0, committed: false, selected: ['LIMIT'] });
+ assert.throws(() => host.commit(), /must be pending/);
+
+ // When the native Post Only tab receives one actual click.
+ view.document.querySelector('[data-tab-key="POST_ONLY"]').click();
+
+ // Then the request is observable without fabricating a committed selection.
+ assert.deepEqual(host.snapshot(), { requests: 1, committed: false, selected: ['LIMIT'] });
+
+ // When the native host publishes its selection and the boundary is later disposed.
+ host.commit();
+ assert.deepEqual(host.snapshot(), { requests: 1, committed: true, selected: ['POST_ONLY'] });
+ assert.throws(() => host.commit(), /must be pending/);
+ host.dispose();
+ view.document.querySelector('[data-tab-key="POST_ONLY"]').click();
+
+ // Then the original native selection remains and the detached listener records no further request.
+ assert.deepEqual(host.snapshot(), { requests: 1, committed: true, selected: ['POST_ONLY'] });
+ assert.equal(view.document.querySelector('[data-tab-key="LIMIT"]'), null);
+});
+
+test('user receives native close quantities separately from the actual close-mode click', t => {
+ // Given the native close form owns a mode transition whose quantity publication has not arrived.
+ const view = openHost(t);
+ const closeTab = view.document.querySelector('[data-trade-mode="CLOSE"]');
+ let documentClicks = 0;
+ let retiredRendererCalls = 0;
+ view.document.addEventListener('click', () => { documentClicks += 1; }, true);
+ closeTab.addEventListener('click', () => { retiredRendererCalls += 1; });
+ const host = installNativeCloseQuantityTransition({ ownerDocument: view.document });
+ assert.throws(() => host.publish({ longQty: '3', shortQty: '0' }), /not pending/);
+
+ // When the user clicks Close before the independent quantity publication.
+ closeTab.click();
+
+ // Then native mode and buttons change while quantities remain absent, and the real document listener ran.
+ assert.equal(documentClicks, 1);
+ assert.equal(retiredRendererCalls, 0);
+ assert.deepEqual(host.snapshot(), {
+ phase: 'quantity-pending', requests: 1, selectedMode: 'CLOSE', quantities: [],
+ buttons: [{ text: '平多', disabled: true }, { text: '平空', disabled: true }],
+ });
+ assert.equal(view.document.querySelector('#limitPrice-close').value, '81.0');
+ assert.equal(view.document.querySelector('#unitAmount-close').value, '');
+ assert.throws(() => host.publish({ longQty: null, shortQty: '0' }), /explicit non-negative decimal strings/);
+
+ // When the independent native quantity publication confirms one long position.
+ host.publish({ longQty: '3', shortQty: '0' });
+
+ // Then the exact quantities and native availability appear without a submit operation.
+ assert.deepEqual(host.snapshot(), {
+ phase: 'complete', requests: 1, selectedMode: 'CLOSE', quantities: ['可平 3 HYPE', '可平 0 HYPE'],
+ buttons: [{ text: '平多', disabled: false }, { text: '平空', disabled: true }],
+ });
+ host.dispose();
+});
+
+test('user measures native DOM reads without changing query results, geometry, or exceptions', t => {
+ // Given the browser boundary preserves its original query, rectangle, and size descriptors.
+ const view = openHost(t);
+ const document = view.document;
+ const row = document.querySelector('.row-content');
+ const book = document.querySelector('#futuresOrderbook');
+ const panel = document.querySelector('#jh-binance-close-qty-multiplier-panel');
+ const spacer = document.querySelector('#jh-binance-close-qty-multiplier-spacer');
+ const originalQuery = view.Document.prototype.querySelectorAll;
+ const originalRect = view.Element.prototype.getBoundingClientRect;
+ const originalHeight = Object.getOwnPropertyDescriptor(view.HTMLElement.prototype, 'offsetHeight');
+ const probe = installOrderEntryReadProbe({ ownerDocument: document });
+
+ // When actual native queries and layout reads touch the book and the panel.
+ const found = document.querySelectorAll('#futuresOrderbook .row-content');
+ const empty = book.querySelectorAll('.absent');
+ const rectangle = row.getBoundingClientRect();
+ const panelHeight = panel.offsetHeight;
+ const anchor = spacer.getBoundingClientRect();
+
+ // Then native results remain exact while each observed operation is counted once.
+ assert.deepEqual([...found], [row]);
+ assert.equal(empty.length, 0);
+ assert.deepEqual({ x: rectangle.x, y: rectangle.y, width: rectangle.width, height: rectangle.height },
+ { x: 0, y: 0, width: 0, height: 0 });
+ assert.equal(panelHeight, 0);
+ assert.equal(anchor.width, 0);
+ assert.throws(() => document.querySelectorAll('['), { name: 'SyntaxError' });
+ assert.deepEqual(probe.snapshot(), {
+ queryCalls: 2, orderbookScans: 2, layoutReads: 3, orderbookLayoutReads: 1,
+ spacerRectReads: 1, panelHeightReads: 1, panelMutations: 0,
+ });
+
+ // When instrumentation is disposed before another native query.
+ const final = probe.dispose();
+ document.querySelectorAll('#futuresOrderbook .row-content');
+
+ // Then original descriptors are restored and the detached counter no longer changes.
+ assert.equal(view.Document.prototype.querySelectorAll, originalQuery);
+ assert.equal(view.Element.prototype.getBoundingClientRect, originalRect);
+ assert.deepEqual(Object.getOwnPropertyDescriptor(view.HTMLElement.prototype, 'offsetHeight'), originalHeight);
+ assert.deepEqual(probe.snapshot(), final);
+});
+
+test('user detects actual panel writes through a real mutation observer and receives a detached count snapshot', async t => {
+ // Given native DOM read instrumentation also observes the mounted panel.
+ const view = openHost(t);
+ const panel = view.document.querySelector('#jh-binance-close-qty-multiplier-panel');
+ const probe = installOrderEntryReadProbe({ ownerDocument: view.document });
+ const initial = probe.snapshot();
+
+ // When the native DOM changes one panel attribute and its existing text node.
+ panel.setAttribute('data-test-state', 'changed');
+ panel.firstChild.firstChild.data = 'Updated panel';
+ await Promise.resolve();
+
+ // Then both writes are measured without changing the earlier snapshot or the actual DOM.
+ assert.equal(initial.panelMutations, 0);
+ assert.equal(probe.snapshot().panelMutations, 2);
+ assert.equal(panel.textContent, 'Updated panel');
+ assert.equal(panel.getAttribute('data-test-state'), 'changed');
+ probe.dispose();
+});
diff --git a/test/unit/binance-orderbook-trade/auto-open-leverage.test.js b/test/unit/binance-orderbook-trade/auto-open-leverage.test.js
index a95ac8a..3dc2f3b 100644
--- a/test/unit/binance-orderbook-trade/auto-open-leverage.test.js
+++ b/test/unit/binance-orderbook-trade/auto-open-leverage.test.js
@@ -1,3 +1,4 @@
+import { captureThrownError } from '../../helpers/orderbook-migration-errors.js';
import test from 'node:test';
import assert from 'node:assert/strict';
@@ -7,27 +8,41 @@ import {
resolveSymbolPositionStatus,
} from '../../../src/binance-orderbook-trade/core/auto-open-leverage.js';
-test('other symbols do not prevent the current symbol from being confirmed flat', () => {
- assert.deepEqual(resolveSymbolPositionStatus({
+test("user sees that other symbols do not prevent the current symbol from being confirmed flat", () => {
+ // Given the current symbol and position observations are available
+ const scenarioInputs = [{
success: true,
data: [
{ symbol: 'BTCUSDT', positionSide: 'BOTH', positionAmount: '0.25' },
{ symbol: 'ETHUSDT', positionSide: 'SHORT', positionAmount: '-1.5' },
],
- }, 'HYPEUSDT'), {
+ }, 'HYPEUSDT'];
+
+ // When the confirmed position transition is evaluated
+ const observed = resolveSymbolPositionStatus(...scenarioInputs);
+
+ // Then sees that other symbols do not prevent the current symbol from being confirmed flat
+ assert.deepEqual(observed, {
status: 'flat',
matchingPositionCount: 0,
});
});
-test('all current-symbol position directions must be zero before reset', () => {
- assert.deepEqual(resolveSymbolPositionStatus({
+test("user sees that all current-symbol position directions must be zero before reset", () => {
+ // Given the current symbol and position observations are available
+ const scenarioInputs = [{
success: true,
data: [
{ symbol: 'HYPEUSDT', positionSide: 'LONG', positionAmount: '0' },
{ symbol: 'HYPEUSDT', positionSide: 'SHORT', positionAmount: '-0.50' },
],
- }, 'HYPEUSDT'), {
+ }, 'HYPEUSDT'];
+
+ // When the confirmed position transition is evaluated
+ const observed = resolveSymbolPositionStatus(...scenarioInputs);
+
+ // Then sees that all current-symbol position directions must be zero before reset
+ assert.deepEqual(observed, {
status: 'has_position',
matchingPositionCount: 2,
});
@@ -44,7 +59,8 @@ test('all current-symbol position directions must be zero before reset', () => {
});
});
-test('close completion checks only the requested position side in hedge mode', () => {
+test("user sees that close completion checks only the requested position side in hedge mode", () => {
+ // Given the current symbol and position observations are available
const payload = {
success: true,
data: [
@@ -53,7 +69,11 @@ test('close completion checks only the requested position side in hedge mode', (
],
};
- assert.deepEqual(resolveSymbolPositionSideStatus(payload, 'HYPEUSDT', 'LONG'), {
+ // When the confirmed position transition is evaluated
+ const observed = resolveSymbolPositionSideStatus(payload, 'HYPEUSDT', 'LONG');
+
+ // Then sees that close completion checks only the requested position side in hedge mode
+ assert.deepEqual(observed, {
status: 'has_position',
matchingPositionCount: 1,
positionQty: '1.25',
@@ -65,7 +85,8 @@ test('close completion checks only the requested position side in hedge mode', (
});
});
-test('close completion maps signed one-way positions to the requested side', () => {
+test("user sees that close completion maps signed one-way positions to the requested side", () => {
+ // Given the current symbol and position observations are available
const longPayload = {
success: true,
data: [{ symbol: 'HYPEUSDT', positionSide: 'BOTH', positionAmount: '1.25' }],
@@ -75,27 +96,36 @@ test('close completion maps signed one-way positions to the requested side', ()
data: [{ symbol: 'HYPEUSDT', positionSide: 'BOTH', positionAmount: '-1.25' }],
};
- assert.equal(resolveSymbolPositionSideStatus(longPayload, 'HYPEUSDT', 'LONG').status, 'has_position');
+ // When the confirmed position transition is evaluated
+ const observed = resolveSymbolPositionSideStatus(longPayload, 'HYPEUSDT', 'LONG').status;
+
+ // Then sees that close completion maps signed one-way positions to the requested side
+ assert.equal(observed, 'has_position');
assert.equal(resolveSymbolPositionSideStatus(longPayload, 'HYPEUSDT', 'SHORT').status, 'flat');
assert.equal(resolveSymbolPositionSideStatus(shortPayload, 'HYPEUSDT', 'LONG').status, 'flat');
assert.equal(resolveSymbolPositionSideStatus(shortPayload, 'HYPEUSDT', 'SHORT').status, 'has_position');
});
-test('close completion rejects unknown position directions instead of guessing', () => {
- assert.throws(
- () => resolveSymbolPositionSideStatus({
+test("user sees that close completion rejects unknown position directions instead of guessing", () => {
+ // Given the current symbol and position observations are available
+ const scenarioInputs = [{
success: true,
data: [{ symbol: 'HYPEUSDT', positionSide: 'UNKNOWN', positionAmount: '1' }],
- }, 'HYPEUSDT', 'LONG'),
- /持仓方向无效/,
- );
+ }, 'HYPEUSDT', 'LONG'];
+
+ // When the confirmed position transition is evaluated
+ const observedFailure = captureThrownError(() => resolveSymbolPositionSideStatus(...scenarioInputs));
+
+ // Then sees that close completion rejects unknown position directions instead of guessing
+ assert.match(observedFailure.message, /持仓方向无效/);
assert.throws(
() => resolveSymbolPositionSideStatus({ success: true, data: [] }, 'HYPEUSDT', 'UNKNOWN'),
/目标持仓方向无效/,
);
});
-test('directional recovery quantities preserve exact signed decimals and existing numeric inputs', () => {
+test("user sees that directional recovery quantities preserve exact signed decimals and existing numeric inputs", () => {
+ // Given the current symbol and position observations are available
for (const [positionSide, positionAmount, side, positionQty] of [
['SHORT', '-1.000000000000000002', 'SHORT', '1.000000000000000002'],
['LONG', '1.000000000000000001', 'LONG', '1.000000000000000001'],
@@ -116,7 +146,11 @@ test('directional recovery quantities preserve exact signed decimals and existin
assert.equal(state.positionQty, positionQty);
assert.equal(state.status, positionQty === '0' ? 'flat' : 'has_position');
}
- assert.deepEqual(resolveSymbolPositionSideStatus({ success: true, data: [] }, 'HYPEUSDT', 'SHORT'), {
+ // When the confirmed position transition is evaluated
+ const observed = resolveSymbolPositionSideStatus({ success: true, data: [] }, 'HYPEUSDT', 'SHORT');
+
+ // Then sees that directional recovery quantities preserve exact signed decimals and existing numeric inputs
+ assert.deepEqual(observed, {
status: 'flat', matchingPositionCount: 0, positionQty: '0',
});
for (const positionAmount of ['1e-8', '--1', 'NaN', Infinity, null]) {
@@ -126,31 +160,34 @@ test('directional recovery quantities preserve exact signed decimals and existin
}
});
-test('rejects unsuccessful or malformed current-symbol position responses', () => {
- assert.throws(
- () => resolveSymbolPositionStatus({ success: false, data: [] }, 'HYPEUSDT'),
- (error) => (
- error.name === 'PositionPayloadContractError'
- && /持仓接口返回失败/.test(error.message)
- ),
- );
- assert.throws(
- () => resolveSymbolPositionStatus({
+test("user rejects unsuccessful or malformed current-symbol position responses", () => {
+ // Given a failed response and a successful response with an unreadable position
+ const payloads = [{ success: false, data: [] }, {
success: true,
data: [{ symbol: 'HYPEUSDT', positionAmount: 'unknown' }],
- }, 'HYPEUSDT'),
- (error) => (
- error.name === 'PositionPayloadContractError'
- && /持仓数量无效/.test(error.message)
- ),
- );
+ }];
+
+ // When position status is read from each response
+ const failures = payloads.map((payload) => captureThrownError(() => resolveSymbolPositionStatus(payload, 'HYPEUSDT')));
+
+ // Then each response fails with the specific position contract error
+ assert.deepEqual(failures.map((error) => error.name), ['PositionPayloadContractError', 'PositionPayloadContractError']);
+ assert.match(failures[0].message, /持仓接口返回失败/);
+ assert.match(failures[1].message, /持仓数量无效/);
});
-test('queues once when a symbol first becomes confirmed flat', () => {
- let observation = observeAutoOpenLeveragePositionState(null, {
+test("user queues once when a symbol first becomes confirmed flat", () => {
+ // Given the current symbol and position observations are available
+ const scenarioInputs = [null, {
symbol: 'HYPEUSDT',
status: 'unknown',
- });
+ }];
+
+ // When the confirmed position transition is evaluated
+ let observation = observeAutoOpenLeveragePositionState(...scenarioInputs);
+
+
+ // Then queues once when a symbol first becomes confirmed flat
assert.equal(observation.shouldReset, false);
observation = observeAutoOpenLeveragePositionState(observation.state, {
@@ -166,11 +203,18 @@ test('queues once when a symbol first becomes confirmed flat', () => {
assert.equal(observation.shouldReset, false);
});
-test('queues once when positions transition from present to flat', () => {
- let observation = observeAutoOpenLeveragePositionState(null, {
+test("user queues once when positions transition from present to flat", () => {
+ // Given the current symbol and position observations are available
+ const scenarioInputs = [null, {
symbol: 'HYPEUSDT',
status: 'has_position',
- });
+ }];
+
+ // When the confirmed position transition is evaluated
+ let observation = observeAutoOpenLeveragePositionState(...scenarioInputs);
+
+
+ // Then queues once when positions transition from present to flat
assert.equal(observation.shouldReset, false);
observation = observeAutoOpenLeveragePositionState(observation.state, {
@@ -180,11 +224,18 @@ test('queues once when positions transition from present to flat', () => {
assert.equal(observation.shouldReset, true);
});
-test('does not create a new flat epoch when the observed root temporarily disappears', () => {
- let observation = observeAutoOpenLeveragePositionState(null, {
+test("user does not create a new flat epoch when the observed root temporarily disappears", () => {
+ // Given the current symbol and position observations are available
+ const scenarioInputs = [null, {
symbol: 'HYPEUSDT',
status: 'flat',
- });
+ }];
+
+ // When the confirmed position transition is evaluated
+ let observation = observeAutoOpenLeveragePositionState(...scenarioInputs);
+
+
+ // Then does not create a new flat epoch when the observed root temporarily disappears
assert.equal(observation.shouldReset, true);
observation = observeAutoOpenLeveragePositionState(observation.state, {
@@ -200,16 +251,19 @@ test('does not create a new flat epoch when the observed root temporarily disapp
assert.equal(observation.shouldReset, false);
});
-test('starts a new flat epoch for a different symbol', () => {
+test("user starts a new flat epoch for a different symbol", () => {
+ // Given the current symbol and position observations are available
const first = observeAutoOpenLeveragePositionState(null, {
symbol: 'HYPEUSDT',
status: 'flat',
});
+ // When the confirmed position transition is evaluated
const second = observeAutoOpenLeveragePositionState(first.state, {
symbol: 'BTCUSDT',
status: 'flat',
});
+ // Then starts a new flat epoch for a different symbol
assert.equal(second.shouldReset, true);
assert.deepEqual(second.state, { symbol: 'BTCUSDT', lastKnownStatus: 'flat' });
});
diff --git a/test/unit/binance-orderbook-trade/binance-native-depth-source.test.js b/test/unit/binance-orderbook-trade/binance-native-depth-source.test.js
index 4933359..fffce92 100644
--- a/test/unit/binance-orderbook-trade/binance-native-depth-source.test.js
+++ b/test/unit/binance-orderbook-trade/binance-native-depth-source.test.js
@@ -1,22 +1,25 @@
import test from 'node:test';
import assert from 'node:assert/strict';
+import { captureThrownError } from '../../helpers/orderbook-migration-errors.js';
import { installBinanceNativeDepthSource } from '../../../src/binance-orderbook-trade/core/binance-native-depth-source.js';
import { createDepthProfileSession } from '../../../src/binance-orderbook-trade/core/depth-profile-session.js';
import { parseFuturesTradingSymbolFromPathname } from '../../../src/shared/binance-futures-route.js';
class FakeResponse {
- constructor(payload, { ok = true, status = 200 } = {}) {
+ constructor(payload, { ok = true, status = 200, jsonError = null } = {}) {
this.payload = payload;
this.ok = ok;
this.status = status;
+ this.jsonError = jsonError;
}
clone() {
- return new FakeResponse(this.payload, { ok: this.ok, status: this.status });
+ return new FakeResponse(this.payload, { ok: this.ok, status: this.status, jsonError: this.jsonError });
}
async json() {
+ if (this.jsonError) throw this.jsonError;
return this.payload;
}
}
@@ -80,8 +83,10 @@ function createHarness(response = new FakeResponse(snapshot())) {
FakeNativeSocket.instances = [];
const fetchCalls = [];
const originalFetch = function originalFetch(...args) {
+ const call = { receiver: this, args, result: null };
+ fetchCalls.push(call);
const result = Promise.resolve(typeof response === 'function' ? response() : response);
- fetchCalls.push({ receiver: this, args, result });
+ call.result = result;
return result;
};
const globalObject = {
@@ -93,7 +98,35 @@ function createHarness(response = new FakeResponse(snapshot())) {
return { fetchCalls, globalObject, originalFetch, source };
}
-test('observes the native RPI snapshot and stream without creating another socket', async () => {
+function recordDepthEvents(source, symbol = 'BTCUSDT') {
+ const profiles = [];
+ const statuses = [];
+ const waiters = new Set();
+ const notify = () => {
+ for (const waiter of waiters) {
+ if (!waiter.matches({ profiles, statuses })) continue;
+ waiters.delete(waiter);
+ waiter.resolve();
+ }
+ };
+ const unsubscribe = source.subscribe({
+ symbol,
+ onProfile(profile) { profiles.push(profile); notify(); },
+ onStatus(status) { statuses.push(status); notify(); },
+ });
+ return {
+ profiles, statuses, unsubscribe,
+ waitFor(matches) {
+ if (matches({ profiles, statuses })) return Promise.resolve();
+ const completion = Promise.withResolvers();
+ waiters.add({ matches, resolve: completion.resolve });
+ return completion.promise;
+ },
+ };
+}
+
+test("user observes the native RPI snapshot and stream without creating another socket", async () => {
+ // Given the native transport and depth subscription are initialized
const { fetchCalls, globalObject, source } = createHarness();
const profiles = [];
const statuses = [];
@@ -107,8 +140,10 @@ test('observes the native RPI snapshot and stream without creating another socke
const responsePromise = globalObject.fetch('/fapi/v1/rpiDepth?symbol=BTCUSDT&limit=1000');
nativeSocket.message(rpiMessage());
const response = await responsePromise;
+ // When Binance delivers the observed depth event
await new Promise((resolve) => setImmediate(resolve));
+ // Then observes the native RPI snapshot and stream without creating another socket
assert.equal(response.ok, true);
assert.equal(FakeNativeSocket.instances.length, 1);
assert.equal(nativeSocket.args[0], 'wss://native-binance-stream.example/ws');
@@ -122,7 +157,8 @@ test('observes the native RPI snapshot and stream without creating another socke
source.restore();
});
-test('retains distant active prices delivered after the 1000-level native snapshot', async () => {
+test("user retains distant active prices delivered after the 1000-level native snapshot", async () => {
+ // Given the native transport and depth subscription are initialized
const denseSnapshot = snapshot({
bids: Array.from({ length: 1000 }, (_, index) => [String(100 - index / 1000), '1']),
asks: Array.from({ length: 1000 }, (_, index) => [String(101 + index / 1000), '1']),
@@ -140,6 +176,7 @@ test('retains distant active prices delivered after the 1000-level native snapsh
nativeSocket.message(rpiMessage());
await responsePromise;
await new Promise((resolve) => setImmediate(resolve));
+ // When Binance delivers the observed depth event
nativeSocket.message(rpiMessage(update({
U: 103,
u: 104,
@@ -149,6 +186,7 @@ test('retains distant active prices delivered after the 1000-level native snapsh
})));
const profile = profiles.at(-1);
+ // Then retains distant active prices delivered after the 1000-level native snapshot
assert.equal(profile.bids.length, 1002);
assert.equal(profile.asks.length, 1002);
assert.equal(profile.bids.at(-1).price, 50);
@@ -156,7 +194,8 @@ test('retains distant active prices delivered after the 1000-level native snapsh
source.restore();
});
-test('preserves native fetch, WebSocket prototype, instanceof, and static constants', async () => {
+test("user preserves native fetch, WebSocket prototype, instanceof, and static constants", async () => {
+ // Given the native transport and depth subscription are initialized
const {
fetchCalls,
globalObject,
@@ -168,9 +207,11 @@ test('preserves native fetch, WebSocket prototype, instanceof, and static consta
const receiver = { marker: 'receiver' };
const fetchResult = Reflect.apply(wrappedFetch, receiver, ['/unrelated']);
+ // When Binance delivers the observed depth event
await fetchResult;
const socket = new WrappedWebSocket('wss://native-binance-stream.example/ws', ['json']);
+ // Then preserves native fetch, WebSocket prototype, instanceof, and static constants
assert.equal(socket instanceof FakeNativeSocket, true);
assert.equal(socket instanceof WrappedWebSocket, true);
assert.equal(wrappedFetch.name, originalFetch.name);
@@ -185,9 +226,11 @@ test('preserves native fetch, WebSocket prototype, instanceof, and static consta
assert.equal(globalObject.WebSocket, FakeNativeSocket);
});
-test('reports a changed native snapshot contract without blocking the Binance fetch', async () => {
+test("user reports a changed native snapshot contract without blocking the Binance fetch", async () => {
+ // Given the native transport and depth subscription are initialized
const { fetchCalls, globalObject, source } = createHarness();
const statuses = [];
+ // When Binance delivers the observed depth event
source.subscribe({
symbol: 'BTCUSDT',
onProfile: () => {},
@@ -196,6 +239,7 @@ test('reports a changed native snapshot contract without blocking the Binance fe
const response = await globalObject.fetch('/fapi/v1/rpiDepth?symbol=BTCUSDT&limit=500');
+ // Then reports a changed native snapshot contract without blocking the Binance fetch
assert.equal(response.ok, true);
assert.equal(fetchCalls.length, 1);
assert.equal(statuses.at(-1).status, 'failed');
@@ -203,9 +247,11 @@ test('reports a changed native snapshot contract without blocking the Binance fe
source.restore();
});
-test('does not block a malformed native snapshot request', async () => {
+test("user does not block a malformed native snapshot request", async () => {
+ // Given the native transport and depth subscription are initialized
const { fetchCalls, globalObject, source } = createHarness();
const statuses = [];
+ // When Binance delivers the observed depth event
source.subscribe({
symbol: 'BTCUSDT',
onProfile: () => {},
@@ -214,6 +260,7 @@ test('does not block a malformed native snapshot request', async () => {
const response = await globalObject.fetch('/fapi/v1/rpiDepth?limit=1000');
+ // Then does not block a malformed native snapshot request
assert.equal(response.ok, true);
assert.equal(fetchCalls.length, 1);
assert.equal(statuses.at(-1).status, 'failed');
@@ -221,7 +268,8 @@ test('does not block a malformed native snapshot request', async () => {
source.restore();
});
-test('keeps the latest native profile for subscribers that start after page initialization', async () => {
+test("user keeps the latest native profile for subscribers that start after page initialization", async () => {
+ // Given the native transport and depth subscription are initialized
const { globalObject, source } = createHarness();
const nativeSocket = new globalObject.WebSocket('wss://native-binance-stream.example/ws');
const responsePromise = globalObject.fetch('/fapi/v1/rpiDepth?symbol=BTCUSDT&limit=1000');
@@ -231,19 +279,22 @@ test('keeps the latest native profile for subscribers that start after page init
const profiles = [];
const statuses = [];
+ // When Binance delivers the observed depth event
source.subscribe({
symbol: 'BTCUSDT',
onProfile: (profile) => profiles.push(profile),
onStatus: (status) => statuses.push(status),
});
+ // Then keeps the latest native profile for subscribers that start after page initialization
assert.equal(profiles.length, 1, JSON.stringify({ statuses, state: source.getState('BTCUSDT') }));
assert.equal(profiles[0].symbol, 'BTCUSDT');
assert.equal(statuses.at(-1).status, 'ready');
source.restore();
});
-test('ignores unrelated native fetches and WebSocket streams', async () => {
+test("user ignores unrelated native fetches and WebSocket streams", async () => {
+ // Given the native transport and depth subscription are initialized
const { globalObject, source } = createHarness();
const profiles = [];
source.subscribe({
@@ -255,13 +306,16 @@ test('ignores unrelated native fetches and WebSocket streams', async () => {
nativeSocket.message({ stream: 'btcusdt@depth@100ms', data: update() });
await globalObject.fetch('/fapi/v1/depth?symbol=BTCUSDT&limit=1000');
+ // When Binance delivers the observed depth event
await Promise.resolve();
+ // Then ignores unrelated native fetches and WebSocket streams
assert.equal(profiles.length, 0);
source.restore();
});
-test('waits for Binance native resynchronization after a sequence gap', async () => {
+test("user waits for Binance native resynchronization after a sequence gap", async () => {
+ // Given the native transport and depth subscription are initialized
const { globalObject, source } = createHarness();
const profiles = [];
const statuses = [];
@@ -274,7 +328,9 @@ test('waits for Binance native resynchronization after a sequence gap', async ()
const responsePromise = globalObject.fetch('/fapi/v1/rpiDepth?symbol=BTCUSDT&limit=1000');
nativeSocket.message(rpiMessage());
await responsePromise;
+ // When Binance delivers the observed depth event
await new Promise((resolve) => setImmediate(resolve));
+ // Then waits for Binance native resynchronization after a sequence gap
assert.equal(profiles.length, 1, JSON.stringify({ statuses, state: source.getState('BTCUSDT') }));
nativeSocket.message(rpiMessage(update({ U: 105, u: 106, pu: 104 })));
@@ -285,7 +341,8 @@ test('waits for Binance native resynchronization after a sequence gap', async ()
source.restore();
});
-test('recovers when Binance performs its next native snapshot synchronization', async () => {
+test("user recovers when Binance performs its next native snapshot synchronization", async () => {
+ // Given the native transport and depth subscription are initialized
let currentResponse = new FakeResponse(snapshot());
const { globalObject, source } = createHarness(() => currentResponse);
const profiles = [];
@@ -301,7 +358,9 @@ test('recovers when Binance performs its next native snapshot synchronization',
nativeSocket.message(rpiMessage());
await responsePromise;
await new Promise((resolve) => setImmediate(resolve));
+ // When Binance delivers the observed depth event
nativeSocket.message(rpiMessage(update({ U: 105, u: 106, pu: 104 })));
+ // Then a sequence gap leaves the profile waiting for native resynchronization
assert.equal(statuses.at(-1).status, 'resyncing');
currentResponse = new FakeResponse(snapshot({ lastUpdateId: 106 }));
@@ -316,7 +375,8 @@ test('recovers when Binance performs its next native snapshot synchronization',
});
for (const symbol of ['龙虾USDT', '币安人生USDT', '4USDT', '1INCHUSDT', '1000龙虾USDT']) {
- test(`connects the encoded ${symbol} route to native snapshot, stream, and session`, async () => {
+ test(`user connects the encoded ${symbol} route to native snapshot, stream, and session`, async () => {
+ // Given the native transport and depth subscription are initialized
const { globalObject, source, fetchCalls } = createHarness();
const route = new URL(`https://www.binance.com/zh-CN/futures/${symbol}`);
const profiles = [];
@@ -331,8 +391,10 @@ for (const symbol of ['龙虾USDT', '币安人生USDT', '4USDT', '1INCHUSDT', '1
const response = globalObject.fetch(`/fapi/v1/rpiDepth?${params}`);
socket.message({ stream: `${symbol.toLowerCase()}@rpiDepth@500ms`, data: update({ s: symbol }) });
await response;
+ // When Binance delivers the observed depth event
await new Promise((resolve) => setImmediate(resolve));
+ // Then the encoded symbol has one ready native profile and stops delivering after cleanup
assert.equal(profiles.length, 1);
assert.equal(profiles[0].symbol, symbol);
assert.equal(profiles[0].bids[0].price, 100);
@@ -348,3 +410,427 @@ for (const symbol of ['龙虾USDT', '币安人生USDT', '4USDT', '1INCHUSDT', '1
source.restore();
});
}
+
+test('user retains native response cloning, JSON failure, and socket event semantics in the transport fixture', async () => {
+ // Given a response clone, a JSON failure, and a socket with two event listeners
+ const payload = snapshot();
+ const jsonError = new SyntaxError('invalid native JSON');
+ const response = new FakeResponse(payload, { status: 206 });
+ const invalidResponse = new FakeResponse(null, { jsonError });
+ const socket = new FakeNativeSocket('wss://fixture.example/ws', ['json']);
+ const events = [];
+ socket.addEventListener('message', (event) => events.push(['first', event.data]));
+ socket.addEventListener('message', (event) => events.push(['second', event.data]));
+
+ // When clones are consumed and the native socket dispatches its message
+ const clone = response.clone();
+ const clonedPayload = await clone.json();
+ const failedJson = invalidResponse.clone().json();
+ socket.message({ stream: 'btcusdt@rpiDepth@500ms', data: { u: 42 } });
+
+ // Then cloning preserves response fields and listeners receive the same encoded event
+ assert.notEqual(clone, response);
+ assert.equal(clonedPayload, payload);
+ assert.equal(clone.status, 206);
+ await assert.rejects(failedJson, (error) => error === jsonError);
+ assert.deepEqual(socket.args, ['wss://fixture.example/ws', ['json']]);
+ assert.deepEqual(events, [
+ ['first', '{"stream":"btcusdt@rpiDepth@500ms","data":{"u":42}}'],
+ ['second', '{"stream":"btcusdt@rpiDepth@500ms","data":{"u":42}}'],
+ ]);
+});
+
+test('user observes a Request-based native snapshot and waits for its first covering update', { timeout: 2000 }, async () => {
+ // Given an active subscription and a native Request object
+ const { globalObject, source, fetchCalls } = createHarness();
+ const events = recordDepthEvents(source);
+ const request = new Request('https://www.binance.com/fapi/v1/rpiDepth?symbol=BTCUSDT&limit=1000');
+
+ // When Binance delivers the snapshot before any covering stream event
+ const response = await globalObject.fetch(request);
+ await events.waitFor(({ statuses }) => statuses.length === 3);
+
+ // Then the snapshot remains synchronizing without publishing an unconfirmed profile
+ assert.equal(response.ok, true);
+ assert.equal(fetchCalls[0].args[0], request);
+ assert.deepEqual(events.profiles, []);
+ assert.equal(source.getState('BTCUSDT').status.status, 'synchronizing');
+
+ // When the native socket supplies the first covering depth event
+ const socket = new globalObject.WebSocket('wss://native-binance-stream.example/ws');
+ socket.message(rpiMessage());
+
+ // Then exactly one ready profile reflects the stream's absolute quantities
+ assert.equal(events.profiles.length, 1);
+ assert.equal(events.profiles[0].bids[0].quantity, 2);
+ assert.equal(events.statuses.at(-1).status, 'ready');
+ source.restore();
+});
+
+test('user sees reconnection only for symbols observed on the native socket that closes', { timeout: 2000 }, async () => {
+ // Given a synchronized native BTC stream and an unrelated ETH subscription
+ const { globalObject, source } = createHarness();
+ const bitcoin = recordDepthEvents(source);
+ const ether = recordDepthEvents(source, 'ETHUSDT');
+ const socket = new globalObject.WebSocket('wss://native-binance-stream.example/ws');
+ globalObject.fetch('/fapi/v1/rpiDepth?symbol=BTCUSDT&limit=1000');
+ socket.message(rpiMessage());
+ await bitcoin.waitFor(({ statuses }) => statuses.at(-1).status === 'ready');
+
+ // When the observed native socket closes
+ socket.emit('close');
+
+ // Then BTC requests native reconnection while ETH retains its previous state
+ assert.equal(bitcoin.statuses.at(-1).status, 'reconnecting');
+ assert.equal(bitcoin.statuses.at(-1).detail, 'Binance native depth socket closed');
+ assert.equal(ether.statuses.at(-1).status, 'connecting');
+ assert.equal(bitcoin.profiles.length, 1);
+ source.restore();
+});
+
+for (const { label, response, expected } of [
+ { label: 'HTTP rejection', response: new FakeResponse(snapshot(), { ok: false, status: 503 }), expected: 'Binance native RPI depth snapshot HTTP 503' },
+ { label: 'JSON rejection', response: new FakeResponse(null, { jsonError: new SyntaxError('native JSON incomplete') }), expected: 'native JSON incomplete' },
+ { label: 'malformed depth snapshot', response: new FakeResponse(snapshot({ bids: null })), expected: 'Invalid depth profile snapshot bids' },
+]) {
+ test(`user sees an explicit native depth failure after ${label}`, { timeout: 2000 }, async () => {
+ // Given the native response cannot supply a valid depth snapshot
+ const { globalObject, source, fetchCalls } = createHarness(response);
+ const events = recordDepthEvents(source);
+
+ // When Binance completes the native snapshot request
+ const received = await globalObject.fetch('/fapi/v1/rpiDepth?symbol=BTCUSDT&limit=1000');
+ await events.waitFor(({ statuses }) => statuses.at(-1).status === 'failed');
+
+ // Then the original response is preserved and the visualization exposes the specific failure
+ assert.equal(received, response);
+ assert.equal(fetchCalls.length, 1);
+ assert.deepEqual(events.profiles, []);
+ assert.equal(source.getState('BTCUSDT').bidCount, 0);
+ if (typeof expected === 'string') assert.equal(events.statuses.at(-1).detail, expected);
+ else assert.match(events.statuses.at(-1).detail, expected);
+ source.restore();
+ });
+}
+
+test('user retains the original asynchronous native fetch rejection while depth becomes failed', { timeout: 2000 }, async () => {
+ // Given the native fetch rejects with its own network error
+ const networkError = new TypeError('native transport unavailable');
+ const { globalObject, source, fetchCalls } = createHarness(() => Promise.reject(networkError));
+ const events = recordDepthEvents(source);
+
+ // When the native snapshot request rejects
+ const request = globalObject.fetch('/fapi/v1/rpiDepth?symbol=BTCUSDT&limit=1000');
+ await assert.rejects(request, (error) => error === networkError);
+ await events.waitFor(({ statuses }) => statuses.at(-1).status === 'failed');
+
+ // Then callers keep the original promise and no synthetic profile is published
+ assert.equal(request, fetchCalls[0].result);
+ assert.equal(events.statuses.at(-1).detail, 'native transport unavailable');
+ assert.deepEqual(events.profiles, []);
+ source.restore();
+});
+
+test('user retains a synchronous native fetch failure without a retry request', () => {
+ // Given native request construction throws before producing a response promise
+ const nativeError = new TypeError('native request construction failed');
+ const { globalObject, source, fetchCalls } = createHarness(() => { throw nativeError; });
+ const events = recordDepthEvents(source);
+
+ // When the observed native request is invoked
+ const failure = captureThrownError(() => globalObject.fetch('/fapi/v1/rpiDepth?symbol=BTCUSDT&limit=1000'));
+
+ // Then the exact native error propagates and the source reports failure once
+ assert.equal(failure, nativeError);
+ assert.equal(fetchCalls.length, 1);
+ assert.equal(events.statuses.at(-1).status, 'failed');
+ assert.equal(events.statuses.at(-1).detail, nativeError.message);
+ source.restore();
+});
+
+for (const { label, event } of [
+ { label: 'invalid JSON', event: { data: '{@rpiDepth@500ms' } },
+ { label: 'uppercase stream name', event: { data: JSON.stringify({ stream: 'BTCUSDT@rpiDepth@500ms', data: update() }) } },
+ { label: 'missing stream data', event: { data: JSON.stringify({ stream: 'btcusdt@rpiDepth@500ms', data: null }) } },
+ { label: 'trailing stream newline', event: { data: JSON.stringify({ stream: 'btcusdt@rpiDepth@500ms\n', data: update() }) } },
+]) {
+ test(`user sees a failed depth contract for ${label}`, () => {
+ // Given an active native depth subscription receives the malformed envelope
+ const { globalObject, source } = createHarness();
+ const events = recordDepthEvents(source);
+ const socket = new globalObject.WebSocket('wss://native-binance-stream.example/ws');
+
+ // When the socket dispatches the malformed native event
+ socket.emit('message', event);
+
+ // Then the failure remains explicit and no partial profile reaches the subscriber
+ assert.equal(events.statuses.at(-1).status, 'failed');
+ assert.deepEqual(events.profiles, []);
+ assert.equal(source.getState('BTCUSDT').askCount, 0);
+ source.restore();
+ });
+}
+
+test('user ignores non-text and unrelated socket events and unsupported request objects', async () => {
+ // Given a subscribed source and a native socket carrying other event formats
+ const { globalObject, source, fetchCalls } = createHarness();
+ const events = recordDepthEvents(source);
+ const socket = new globalObject.WebSocket('wss://native-binance-stream.example/ws');
+
+ // When unrelated native traffic is dispatched
+ socket.emit('message');
+ socket.emit('message', { data: new Uint8Array([1, 2]) });
+ socket.message({ stream: 'btcusdt@aggTrade', data: { p: '100' } });
+ await globalObject.fetch(new URL('https://www.binance.com/unrelated'));
+
+ // Then the adapter passes the request through and leaves depth discovery unchanged
+ assert.equal(fetchCalls.length, 1);
+ assert.deepEqual(events.statuses, [{ symbol: 'BTCUSDT', status: 'connecting', detail: '' }]);
+ assert.deepEqual(events.profiles, []);
+ assert.equal(source.getState('ETHUSDT'), null);
+ source.restore();
+});
+
+test('user rejects depth updates for a different symbol without publishing their quantities', () => {
+ // Given the subscribed stream claims BTC while the event payload belongs to ETH
+ const { globalObject, source } = createHarness();
+ const events = recordDepthEvents(source);
+ const socket = new globalObject.WebSocket('wss://native-binance-stream.example/ws');
+
+ // When the inconsistent native depth message arrives
+ socket.message(rpiMessage(update({ s: 'ETHUSDT' })));
+
+ // Then the current symbol fails explicitly without exposing another contract's book
+ assert.equal(events.statuses.at(-1).status, 'failed');
+ assert.match(events.statuses.at(-1).detail, /symbol/);
+ assert.deepEqual(events.profiles, []);
+ source.restore();
+});
+
+test('user releases unsubscribed symbol state when the next native snapshot starts', { timeout: 2000 }, async () => {
+ // Given BTC no longer has a subscriber and ETH becomes the active native snapshot
+ const { globalObject, source } = createHarness();
+ const bitcoin = recordDepthEvents(source);
+ const ether = recordDepthEvents(source, 'ETHUSDT');
+ bitcoin.unsubscribe();
+
+ // When the next symbol synchronizes from its own native snapshot and stream
+ globalObject.fetch('/fapi/v1/rpiDepth?symbol=ETHUSDT&limit=1000');
+ const socket = new globalObject.WebSocket('wss://native-binance-stream.example/ws');
+ socket.message({ stream: 'ethusdt@rpiDepth@500ms', data: update({ s: 'ETHUSDT' }) });
+ await ether.waitFor(({ statuses }) => statuses.at(-1).status === 'ready');
+
+ // Then only the subscribed symbol retains a ready profile
+ assert.equal(source.getState('BTCUSDT'), null);
+ assert.equal(source.getState('ETHUSDT').status.status, 'ready');
+ assert.equal(ether.profiles[0].symbol, 'ETHUSDT');
+ assert.deepEqual(bitcoin.profiles, []);
+ source.restore();
+});
+
+test('user keeps later native transport owners when the depth source is restored twice', () => {
+ // Given another page owner has replaced both instrumented transports
+ const { globalObject, source } = createHarness();
+ const nextFetch = () => Promise.resolve(new FakeResponse(snapshot()));
+ class NextSocket extends FakeNativeSocket {}
+ globalObject.fetch = nextFetch;
+ globalObject.WebSocket = NextSocket;
+
+ // When the old depth observation is restored and restoration repeats
+ source.restore();
+ source.restore();
+ const failure = captureThrownError(() => source.subscribe({
+ symbol: 'BTCUSDT', onProfile() {}, onStatus() {},
+ }));
+
+ // Then the later owner remains installed and a stopped source rejects new subscriptions
+ assert.equal(globalObject.fetch, nextFetch);
+ assert.equal(globalObject.WebSocket, NextSocket);
+ assert.equal(failure.message, 'Binance native depth source has been restored');
+});
+
+test('user receives no later profile or reconnect event after source restoration', { timeout: 2000 }, async () => {
+ // Given a native snapshot request is pending while a socket already has a BTC update
+ const pendingResponse = Promise.withResolvers();
+ const { globalObject, source } = createHarness(() => pendingResponse.promise);
+ const events = recordDepthEvents(source);
+ const socket = new globalObject.WebSocket('wss://native-binance-stream.example/ws');
+ const request = globalObject.fetch('/fapi/v1/rpiDepth?symbol=BTCUSDT&limit=1000');
+ socket.message(rpiMessage());
+ const recordedStatuses = events.statuses.length;
+
+ // When the source is restored before the native response and socket close arrive
+ source.restore();
+ pendingResponse.resolve(new FakeResponse(snapshot()));
+ await request;
+ socket.message(rpiMessage(update({ U: 103, u: 104, pu: 102 })));
+ socket.emit('close');
+ await new Promise((resolve) => setImmediate(resolve));
+
+ // Then old transport events cannot revive the stopped visualization
+ assert.equal(source.getState('BTCUSDT'), null);
+ assert.equal(events.statuses.length, recordedStatuses);
+ assert.deepEqual(events.profiles, []);
+});
+
+for (const { label, settlement, resultField, expectedStatus, nativeResult } of [
+ {
+ label: 'successful snapshot', settlement: 'resolve', resultField: 'value', expectedStatus: 'fulfilled',
+ nativeResult: new FakeResponse(snapshot()),
+ },
+ {
+ label: 'HTTP failure', settlement: 'resolve', resultField: 'value', expectedStatus: 'fulfilled',
+ nativeResult: new FakeResponse(snapshot(), { ok: false, status: 503 }),
+ },
+ {
+ label: 'JSON failure', settlement: 'resolve', resultField: 'value', expectedStatus: 'fulfilled',
+ nativeResult: new FakeResponse(null, { jsonError: new SyntaxError('late native JSON failure') }),
+ },
+ {
+ label: 'network rejection', settlement: 'reject', resultField: 'reason', expectedStatus: 'rejected',
+ nativeResult: new TypeError('late native network rejection'),
+ },
+]) {
+ test(`user keeps a restored source empty when a pending native request completes with ${label}`, async () => {
+ // Given a native snapshot is pending while the depth subscriber is active
+ const pendingResponse = Promise.withResolvers();
+ const { globalObject, source, fetchCalls } = createHarness(() => pendingResponse.promise);
+ const events = recordDepthEvents(source);
+ const request = globalObject.fetch('/fapi/v1/rpiDepth?symbol=BTCUSDT&limit=1000');
+ const statusesBeforeRestore = [...events.statuses];
+
+ // When the source is restored before the original native promise settles
+ source.restore();
+ pendingResponse[settlement](nativeResult);
+ const [result] = await Promise.allSettled([request]);
+ await new Promise((resolve) => setImmediate(resolve));
+
+ // Then callers retain native results and late observation cannot revive source state
+ assert.equal(request, pendingResponse.promise);
+ assert.equal(request, fetchCalls[0].result);
+ assert.equal(fetchCalls.length, 1);
+ assert.equal(result.status, expectedStatus);
+ assert.equal(result[resultField], nativeResult);
+ assert.equal(source.getState('BTCUSDT'), null);
+ assert.deepEqual(events.statuses, statusesBeforeRestore);
+ assert.deepEqual(events.profiles, []);
+ });
+}
+
+for (const { label, limit, rejects } of [
+ { label: 'successful response', limit: '1000', rejects: false },
+ { label: 'native promise rejection', limit: '1000', rejects: true },
+ { label: 'changed snapshot limit', limit: '500', rejects: false },
+]) {
+ test(`user invokes a cached fetch after restoration with ${label} and no depth observation`, async () => {
+ // Given page code cached the wrapper before its source was restored
+ const response = new FakeResponse(snapshot());
+ const nativeError = new TypeError('cached native fetch rejection');
+ const { globalObject, source, fetchCalls } = createHarness(
+ () => rejects ? Promise.reject(nativeError) : response,
+ );
+ const cachedFetch = globalObject.fetch;
+ const events = recordDepthEvents(source);
+ const statusesBeforeRestore = [...events.statuses];
+ source.restore();
+ const receiver = { name: 'native request owner' };
+ const request = new Request(`https://www.binance.com/fapi/v1/rpiDepth?symbol=BTCUSDT&limit=${limit}`);
+ const options = { cache: 'no-store' };
+
+ // When page code invokes its cached fetch with the original receiver and arguments
+ const nativePromise = Reflect.apply(cachedFetch, receiver, [request, options]);
+ const [result] = await Promise.allSettled([nativePromise]);
+ await new Promise((resolve) => setImmediate(resolve));
+
+ // Then the wrapper only delegates once and preserves the native promise and outcome
+ assert.equal(fetchCalls.length, 1);
+ assert.equal(fetchCalls[0].receiver, receiver);
+ assert.equal(fetchCalls[0].args[0], request);
+ assert.equal(fetchCalls[0].args[1], options);
+ assert.equal(nativePromise, fetchCalls[0].result);
+ assert.equal(result.status, rejects ? 'rejected' : 'fulfilled');
+ assert.equal(result[rejects ? 'reason' : 'value'], rejects ? nativeError : response);
+ assert.equal(source.getState('BTCUSDT'), null);
+ assert.deepEqual(events.statuses, statusesBeforeRestore);
+ assert.deepEqual(events.profiles, []);
+ });
+}
+
+test('user retains a synchronous cached fetch failure after restoration without reviving depth state', () => {
+ // Given the cached wrapper's native host throws during request construction
+ const nativeError = new TypeError('restored native request construction failed');
+ const { globalObject, source, fetchCalls } = createHarness(() => { throw nativeError; });
+ const cachedFetch = globalObject.fetch;
+ const events = recordDepthEvents(source);
+ const statusesBeforeRestore = [...events.statuses];
+ source.restore();
+ const receiver = { name: 'cached request owner' };
+ const input = '/fapi/v1/rpiDepth?symbol=BTCUSDT&limit=1000';
+ const options = { cache: 'no-store' };
+
+ // When page code calls its cached wrapper after restoration
+ const failure = captureThrownError(() => Reflect.apply(cachedFetch, receiver, [input, options]));
+
+ // Then the host error propagates unchanged and no observer record is recreated
+ assert.equal(failure, nativeError);
+ assert.equal(fetchCalls.length, 1);
+ assert.equal(fetchCalls[0].receiver, receiver);
+ assert.equal(fetchCalls[0].args[0], input);
+ assert.equal(fetchCalls[0].args[1], options);
+ assert.equal(fetchCalls[0].result, null);
+ assert.equal(source.getState('BTCUSDT'), null);
+ assert.deepEqual(events.statuses, statusesBeforeRestore);
+ assert.deepEqual(events.profiles, []);
+});
+
+test('user cannot recreate a depth record by subscribing after source restoration', () => {
+ // Given restoration cleared a source that previously had an active subscriber
+ const { source } = createHarness();
+ const events = recordDepthEvents(source);
+ const statusesBeforeRestore = [...events.statuses];
+ source.restore();
+ const laterProfiles = [];
+ const laterStatuses = [];
+
+ // When another consumer tries to subscribe to the restored source
+ const failure = captureThrownError(() => source.subscribe({
+ symbol: 'BTCUSDT',
+ onProfile: (profile) => laterProfiles.push(profile),
+ onStatus: (status) => laterStatuses.push(status),
+ }));
+
+ // Then the explicit lifecycle error leaves every source record and notification empty
+ assert.equal(failure.message, 'Binance native depth source has been restored');
+ assert.equal(source.getState('BTCUSDT'), null);
+ assert.deepEqual(events.statuses, statusesBeforeRestore);
+ assert.deepEqual(events.profiles, []);
+ assert.deepEqual(laterStatuses, []);
+ assert.deepEqual(laterProfiles, []);
+});
+
+test('user constructs native sockets through a cached constructor after restoration without observers', () => {
+ // Given page code cached the wrapped constructor before observation was restored
+ const { globalObject, source } = createHarness();
+ const CachedWebSocket = globalObject.WebSocket;
+ const events = recordDepthEvents(source);
+ const statusesBeforeRestore = [...events.statuses];
+ source.restore();
+ const socketUrl = 'wss://native-binance-stream.example/ws';
+ const protocols = ['json'];
+
+ // When the cached constructor creates the next page-owned native socket
+ const socket = new CachedWebSocket(socketUrl, protocols);
+
+ // Then the original instance and arguments survive without adding depth listeners
+ assert.equal(socket, FakeNativeSocket.instances[0]);
+ assert.equal(FakeNativeSocket.instances.length, 1);
+ assert.equal(socket instanceof FakeNativeSocket, true);
+ assert.equal(socket instanceof CachedWebSocket, true);
+ assert.equal(socket.constructor, FakeNativeSocket);
+ assert.deepEqual(socket.args, [socketUrl, protocols]);
+ assert.equal(socket.args[1], protocols);
+ assert.equal(socket.listeners.size, 0);
+ assert.equal(source.getState('BTCUSDT'), null);
+ assert.deepEqual(events.statuses, statusesBeforeRestore);
+ assert.deepEqual(events.profiles, []);
+});
diff --git a/test/unit/binance-orderbook-trade/binance-page-text.test.js b/test/unit/binance-orderbook-trade/binance-page-text.test.js
index 9888f60..f8c9752 100644
--- a/test/unit/binance-orderbook-trade/binance-page-text.test.js
+++ b/test/unit/binance-orderbook-trade/binance-page-text.test.js
@@ -10,8 +10,15 @@ import {
startsWithBinancePageText,
} from '../../../src/binance-orderbook-trade/contracts/binance-page-text.js';
-test('centralizes the verified Chinese and English Binance page labels', () => {
- assert.equal(matchesBinancePageText('开仓', BINANCE_PAGE_TEXT.tradeMode.OPEN), true);
+test("user centralizes the verified Chinese and English Binance page labels", () => {
+ // Given the page provides localized Binance labels
+ const scenarioInputs = ['开仓', BINANCE_PAGE_TEXT.tradeMode.OPEN];
+
+ // When the native label contract is evaluated
+ const observed = matchesBinancePageText(...scenarioInputs);
+
+ // Then centralizes the verified Chinese and English Binance page labels
+ assert.equal(observed, true);
assert.equal(matchesBinancePageText('Open', BINANCE_PAGE_TEXT.tradeMode.OPEN), true);
assert.equal(matchesBinancePageText('可用', BINANCE_PAGE_TEXT.availableBalance), true);
assert.equal(matchesBinancePageText('Avbl', BINANCE_PAGE_TEXT.availableBalance), true);
@@ -19,22 +26,43 @@ test('centralizes the verified Chinese and English Binance page labels', () => {
assert.equal(matchesBinancePageText('Cancel Order', BINANCE_PAGE_TEXT.accountOrders.rowCancel), true);
});
-test('matches the verified account-order subtab labels and counts', () => {
- assert.equal(startsWithBinancePageText('基础单(29)', BINANCE_PAGE_TEXT.accountOrders.basicSubTab), true);
+test("user matches the verified account-order subtab labels and counts", () => {
+ // Given the page provides localized Binance labels
+ const scenarioInputs = ['基础单(29)', BINANCE_PAGE_TEXT.accountOrders.basicSubTab];
+
+ // When the native label contract is evaluated
+ const observed = startsWithBinancePageText(...scenarioInputs);
+
+ // Then matches the verified account-order subtab labels and counts
+ assert.equal(observed, true);
assert.equal(startsWithBinancePageText('Basic(31)', BINANCE_PAGE_TEXT.accountOrders.basicSubTab), true);
assert.equal(startsWithBinancePageText('条件委托(0)', BINANCE_PAGE_TEXT.accountOrders.conditionalSubTab), true);
assert.equal(startsWithBinancePageText('Conditional(0)', BINANCE_PAGE_TEXT.accountOrders.conditionalSubTab), true);
});
-test('parses localized tab counts through the shared page-text contract', () => {
- assert.equal(parseBinanceTabCount('当前委托(4)', BINANCE_PAGE_TEXT.accountOrders.openOrdersTab), 4);
+test("user parses localized tab counts through the shared page-text contract", () => {
+ // Given the page provides localized Binance labels
+ const scenarioInputs = ['当前委托(4)', BINANCE_PAGE_TEXT.accountOrders.openOrdersTab];
+
+ // When the native label contract is evaluated
+ const observed = parseBinanceTabCount(...scenarioInputs);
+
+ // Then parses localized tab counts through the shared page-text contract
+ assert.equal(observed, 4);
assert.equal(parseBinanceTabCount('Open Orders (12)', BINANCE_PAGE_TEXT.accountOrders.openOrdersTab), 12);
assert.equal(parseBinanceTabCount('Positions(1)', BINANCE_PAGE_TEXT.accountOrders.positionTab), 1);
assert.equal(parseBinanceTabCount('Open Orders', BINANCE_PAGE_TEXT.accountOrders.openOrdersTab), null);
});
-test('matches additional verified Binance page fragments', () => {
- assert.equal(includesBinancePageText('只做Ｍaker (Post Only)', BINANCE_PAGE_TEXT.postOnly), true);
+test("user matches additional verified Binance page fragments", () => {
+ // Given the page provides localized Binance labels
+ const scenarioInputs = ['只做Ｍaker (Post Only)', BINANCE_PAGE_TEXT.postOnly];
+
+ // When the native label contract is evaluated
+ const observed = includesBinancePageText(...scenarioInputs);
+
+ // Then matches additional verified Binance page fragments
+ assert.equal(observed, true);
assert.equal(includesBinancePageText('HYPEUSDT Perp', BINANCE_PAGE_TEXT.accountOrders.perpetual), true);
assert.equal(includesBinancePageText('Hide Other Symbols', BINANCE_PAGE_TEXT.accountOrders.hideOtherSymbols), true);
assert.equal(includesCompactBinancePageText('Open Long / Limit', BINANCE_PAGE_TEXT.tradeAction.OPEN_LONG), true);
diff --git a/test/unit/binance-orderbook-trade/cancel-all-dialog.test.js b/test/unit/binance-orderbook-trade/cancel-all-dialog.test.js
index 2665e9e..ef3095c 100644
--- a/test/unit/binance-orderbook-trade/cancel-all-dialog.test.js
+++ b/test/unit/binance-orderbook-trade/cancel-all-dialog.test.js
@@ -1,3 +1,4 @@
+import { captureThrownError } from '../../helpers/orderbook-migration-errors.js';
import test from 'node:test';
import assert from 'node:assert/strict';
@@ -7,6 +8,7 @@ import {
classifyBinanceCancelAllDialogKeyboardAction,
createDialogMutationSignal,
findBinanceCancelAllDialog,
+ mutationTouchesDialogCandidate,
waitForDialogMutationState,
} from '../../../src/binance-orderbook-trade/dom/cancel-all-dialog.js';
@@ -23,27 +25,36 @@ function createDialogMarkup({ text = '确定取消全部订单？', extraButton
`;
}
-test('finds one semantic Binance cancel-all action pair through nested modal wrappers', () => {
+test("user finds one semantic Binance cancel-all action pair through nested modal wrappers", () => {
+ // Given the native cancellation dialog and caller state are available
const dom = loadFixtureDom(createDialogMarkup());
+ // When the dialog action or lifecycle event is observed
const contract = findBinanceCancelAllDialog(dom.window.document, isVisibleElement);
+ // Then finds one semantic Binance cancel-all action pair through nested modal wrappers
assert.equal(contract.dialog.getAttribute('data-testid'), 'dialog');
assert.equal(contract.cancelButton.textContent.trim(), '取消');
assert.equal(contract.confirmButton.textContent.trim(), '确认');
});
-test('finds the verified English cancel-all dialog contract', () => {
+test("user finds the verified English cancel-all dialog contract", () => {
+ // Given the native cancellation dialog and caller state are available
const dom = loadFixtureDom(createDialogMarkup({ text: 'Cancel all orders?' }));
+ // When the dialog action or lifecycle event is observed
const contract = findBinanceCancelAllDialog(dom.window.document, isVisibleElement);
+ // Then finds the verified English cancel-all dialog contract
assert.equal(contract.dialog.getAttribute('data-testid'), 'dialog');
assert.equal(contract.confirmButton.classList.contains('bn-button__primary'), true);
});
-test('classifies nested confirm targets and the secondary cancel button', () => {
+test("user sees that classifies nested confirm targets and the secondary cancel button", () => {
+ // Given the native cancellation dialog and caller state are available
const dom = loadFixtureDom(createDialogMarkup());
+ // When the dialog action or lifecycle event is observed
const contract = findBinanceCancelAllDialog(dom.window.document, isVisibleElement);
+ // Then sees that classifies nested confirm targets and the secondary cancel button
assert.equal(
classifyBinanceCancelAllDialogAction(contract, contract.confirmButton.querySelector('span')),
'confirmed',
@@ -58,10 +69,13 @@ test('classifies nested confirm targets and the secondary cancel button', () =>
);
});
-test('classifies keyboard decisions including default Enter confirmation without button focus', () => {
+test("user sees that classifies keyboard decisions including default Enter confirmation without button focus", () => {
+ // Given the native cancellation dialog and caller state are available
const dom = loadFixtureDom(createDialogMarkup());
+ // When the dialog action or lifecycle event is observed
const contract = findBinanceCancelAllDialog(dom.window.document, isVisibleElement);
+ // Then sees that classifies keyboard decisions including default Enter confirmation without button focus
assert.equal(
classifyBinanceCancelAllDialogKeyboardAction(contract, 'Enter', dom.window.document.body),
'confirmed',
@@ -76,10 +90,15 @@ test('classifies keyboard decisions including default Enter confirmation without
);
});
-test('ignores unrelated dialogs and rejects invalid cancel-all button contracts', () => {
+test("user ignores unrelated dialogs and rejects invalid cancel-all button contracts", () => {
+ // Given the native cancellation dialog and caller state are available
const unrelatedDom = loadFixtureDom(createDialogMarkup({ text: '调整保证金' }));
+ // When the dialog action or lifecycle event is observed
+ const observed = findBinanceCancelAllDialog(unrelatedDom.window.document, isVisibleElement);
+
+ // Then ignores unrelated dialogs and rejects invalid cancel-all button contracts
assert.equal(
- findBinanceCancelAllDialog(unrelatedDom.window.document, isVisibleElement),
+ observed,
null,
);
@@ -92,22 +111,35 @@ test('ignores unrelated dialogs and rejects invalid cancel-all button contracts'
);
});
-test('rejects multiple semantic cancel-all dialogs with distinct action pairs', () => {
+test("user rejects multiple semantic cancel-all dialogs with distinct action pairs", () => {
+ // Given the native cancellation dialog and caller state are available
const dom = loadFixtureDom(`${createDialogMarkup()}${createDialogMarkup()}`);
- assert.throws(
- () => findBinanceCancelAllDialog(dom.window.document, isVisibleElement),
- /撤单确认弹窗操作区域数量异常：2/,
- );
+ // When the dialog action or lifecycle event is observed
+ const observedFailure = captureThrownError(() => findBinanceCancelAllDialog(dom.window.document, isVisibleElement));
+
+ // Then rejects multiple semantic cancel-all dialogs with distinct action pairs
+ assert.match(observedFailure.message, /撤单确认弹窗操作区域数量异常：2/);
});
-test('dialog mutation signal ignores unrelated DOM churn and reports dialog insertion', async () => {
+test("user sees that dialog mutation signal ignores unrelated DOM churn and reports dialog insertion", async () => {
+ // Given the native cancellation dialog and caller state are available
const dom = loadFixtureDom('');
const { document } = dom.window;
const signal = createDialogMutationSignal(document);
const initialVersion = signal.version;
+ const delivered = Promise.withResolvers();
+ const unrelatedObserver = new dom.window.MutationObserver((mutations) => {
+ unrelatedObserver.disconnect();
+ delivered.resolve(mutations);
+ });
+ unrelatedObserver.observe(document.querySelector('#app'), { childList: true });
+ // When the dialog action or lifecycle event is observed
document.querySelector('#app').append(document.createElement('span'));
- await new Promise((resolve) => dom.window.setTimeout(resolve, 0));
+ const unrelatedMutations = await delivered.promise;
+ // Then sees that dialog mutation signal ignores unrelated DOM churn and reports dialog insertion
+ assert.equal(unrelatedMutations.length, 1);
+ assert.equal(unrelatedMutations[0].addedNodes[0].tagName, 'SPAN');
assert.equal(signal.version, initialVersion);
document.body.insertAdjacentHTML('beforeend', createDialogMarkup());
@@ -116,7 +148,8 @@ test('dialog mutation signal ignores unrelated DOM churn and reports dialog inse
signal.dispose();
});
-test('dialog mutation state resolves when React removes the dialog wrapper', async () => {
+test("user sees that dialog mutation state resolves when React removes the dialog wrapper", async () => {
+ // Given the native cancellation dialog and caller state are available
const dom = loadFixtureDom(createDialogMarkup());
const { document } = dom.window;
const dialog = document.querySelector('[role="dialog"]');
@@ -126,17 +159,20 @@ test('dialog mutation state resolves when React removes the dialog wrapper', asy
100,
);
+ // When the dialog action or lifecycle event is observed
dialog.parentElement.remove();
+ // Then sees that dialog mutation state resolves when React removes the dialog wrapper
assert.equal(await pending, 'closed');
});
-test('dialog mutation state aborts immediately with the caller-provided reason', async () => {
+test("user aborts dialog mutation state with the caller-provided reason before its deadline", async (t) => {
+ // Given the native cancellation dialog and caller state are available
const dom = loadFixtureDom(createDialogMarkup());
const { document } = dom.window;
const controller = new AbortController();
const reason = new Error('ladder stopped');
- const startedAt = Date.now();
+ t.mock.timers.enable({ apis: ['Date', 'setTimeout'], now: 1000 });
const pending = waitForDialogMutationState(
document,
() => null,
@@ -144,8 +180,184 @@ test('dialog mutation state aborts immediately with the caller-provided reason',
controller.signal,
);
+ // When the dialog action or lifecycle event is observed
controller.abort(reason);
+ // Then sees that dialog mutation state aborts immediately with the caller-provided reason
await assert.rejects(pending, (error) => error === reason);
- assert.ok(Date.now() - startedAt < 100, 'abort should not wait for the dialog deadline');
+ assert.equal(Date.now(), 1000);
+});
+
+test('user applies Space only to the focused native dialog button and ignores unrelated keys', () => {
+ // Given a verified native cancel dialog has both actions and another mounted button
+ const { window } = loadFixtureDom(createDialogMarkup());
+ const contract = findBinanceCancelAllDialog(window.document, isVisibleElement);
+ const otherButton = window.document.createElement('button');
+ contract.dialog.append(otherButton);
+
+ // When keyboard decisions and an unrelated action are classified
+ const confirm = classifyBinanceCancelAllDialogKeyboardAction(contract, ' ', contract.confirmButton);
+ const cancel = classifyBinanceCancelAllDialogKeyboardAction(contract, ' ', contract.cancelButton);
+ const unfocused = classifyBinanceCancelAllDialogKeyboardAction(contract, ' ', window.document.body);
+ const unrelatedKey = classifyBinanceCancelAllDialogKeyboardAction(contract, 'Tab', contract.confirmButton);
+ const unrelatedAction = classifyBinanceCancelAllDialogAction(contract, otherButton);
+ const absentAction = classifyBinanceCancelAllDialogAction(contract, null);
+
+ // Then explicit native focus determines Space and unknown actions remain undecided
+ assert.equal(confirm, 'confirmed');
+ assert.equal(cancel, 'cancelled');
+ assert.equal(unfocused, null);
+ assert.equal(unrelatedKey, null);
+ assert.equal(unrelatedAction, null);
+ assert.equal(absentAction, null);
+});
+
+for (const primaryCount of [0, 2]) {
+ test(`user rejects a cancel dialog containing ${primaryCount} primary actions`, () => {
+ // Given the native-looking dialog has two buttons but no unique primary action
+ const { window } = loadFixtureDom(createDialogMarkup());
+ const buttons = window.document.querySelectorAll('button');
+ for (const button of buttons) button.classList.toggle('bn-button__primary', primaryCount === 2);
+
+ // When the cancellation dialog contract is resolved
+ const failure = captureThrownError(() => findBinanceCancelAllDialog(window.document, isVisibleElement));
+
+ // Then the ambiguous confirmation contract is rejected explicitly
+ assert.equal(failure.message, `撤单确认按钮数量异常：${primaryCount}`);
+ });
+}
+
+test('user ignores hidden dialog wrappers and native dialogs without visible action buttons', () => {
+ // Given all native action buttons are hidden while a separate candidate wrapper is also hidden
+ const { window } = loadFixtureDom(createDialogMarkup());
+ window.document.querySelector('.bn-modal-root').setAttribute('data-hidden', '');
+ for (const button of window.document.querySelectorAll('button')) button.setAttribute('data-hidden', '');
+
+ // When native cancellation discovery reads the mounted candidates
+ const dialog = findBinanceCancelAllDialog(window.document, isVisibleElement);
+
+ // Then no hidden or actionless candidate becomes a valid confirmation contract
+ assert.equal(dialog, null);
+});
+
+test('user classifies real dialog attribute and subtree mutations without treating text churn as a dialog event', () => {
+ // Given a real observer captures native dialog changes and unrelated page content
+ const { window } = loadFixtureDom(`${createDialogMarkup()}outside`);
+ const observer = new window.MutationObserver(() => {});
+ observer.observe(window.document.body, { childList: true, subtree: true, attributes: true, characterData: true });
+ const dialog = window.document.querySelector('[role="dialog"]');
+
+ // When native attributes, nested buttons, outside text, and a wrapper removal change
+ dialog.setAttribute('aria-hidden', 'false');
+ const attributeMutation = observer.takeRecords()[0];
+ dialog.append(window.document.createElement('span'));
+ const nestedMutation = observer.takeRecords()[0];
+ window.document.querySelector('#outside').firstChild.data = 'updated';
+ const textMutation = observer.takeRecords()[0];
+ dialog.parentElement.remove();
+ const removedMutation = observer.takeRecords()[0];
+ observer.disconnect();
+ const classified = [attributeMutation, nestedMutation, textMutation, removedMutation, null]
+ .map(mutationTouchesDialogCandidate);
+
+ // Then only the actual dialog-affecting records request a dialog state refresh
+ assert.deepEqual(classified, [true, true, false, true, false]);
+});
+
+test('user wakes an indefinite dialog wait through explicit notification and observes its new version', async () => {
+ // Given a dialog signal waits without a timeout for an explicit native decision event
+ const { window } = loadFixtureDom('');
+ const signal = createDialogMutationSignal(window.document);
+ const initialVersion = signal.version;
+ const pending = signal.waitForChange(initialVersion);
+
+ // When the native decision listener notifies the dialog signal
+ signal.notify();
+ const result = await pending;
+ const alreadyChanged = await signal.waitForChange(initialVersion);
+
+ // Then both the pending and later stale-version consumers observe that exact change
+ assert.equal(result, 'changed');
+ assert.equal(alreadyChanged, 'changed');
+ assert.equal(signal.version, initialVersion + 1);
+ signal.dispose();
+});
+
+test('user reaches a dialog signal deadline only after the virtual clock expires', async (t) => {
+ // Given no native dialog event has occurred during a bounded wait
+ const { window } = loadFixtureDom('');
+ const signal = createDialogMutationSignal(window.document);
+ t.mock.timers.enable({ apis: ['setTimeout'] });
+ let result = 'pending';
+ const pending = signal.waitForChange(signal.version, 50).then((value) => { result = value; return value; });
+
+ // When the clock stops immediately before the deadline
+ t.mock.timers.tick(49);
+ await Promise.resolve();
+
+ // Then the source still awaits a real dialog event
+ assert.equal(result, 'pending');
+
+ // When the virtual deadline is reached
+ t.mock.timers.tick(1);
+ const outcome = await pending;
+
+ // Then timeout ends the wait without inventing a dialog change
+ assert.equal(outcome, 'timeout');
+ assert.equal(signal.version, 0);
+ signal.dispose();
+});
+
+test('user releases an indefinite dialog wait when its observer is disposed', async () => {
+ // Given a live dialog signal has an indefinite waiter
+ const { window } = loadFixtureDom('');
+ const signal = createDialogMutationSignal(window.document);
+ const pending = signal.waitForChange(signal.version);
+
+ // When the dialog workflow disposes its observer
+ signal.dispose();
+ const result = await pending;
+
+ // Then disposal settles the waiter without incrementing the event version
+ assert.equal(result, 'disposed');
+ assert.equal(signal.version, 0);
+});
+
+test('user reads existing dialog state without a document and leaves absent state unresolved', async () => {
+ // Given a confirmed dialog state is already available to one reader
+ const current = { decision: 'cancelled' };
+
+ // When state waiters run without an observable document
+ const ready = await waitForDialogMutationState(null, () => current, 1000);
+ const absent = await waitForDialogMutationState(null, () => null, 1000);
+ const signal = createDialogMutationSignal(null);
+
+ // Then existing state retains identity while absent observation produces no decision
+ assert.equal(ready, current);
+ assert.equal(absent, null);
+ assert.equal(signal, null);
+});
+
+test('user finishes a dialog state wait at its exact virtual deadline', async (t) => {
+ // Given the mounted document has no cancellation dialog yet
+ const { window } = loadFixtureDom('');
+ t.mock.timers.enable({ apis: ['Date', 'setTimeout'], now: 1000 });
+ let outcome = 'pending';
+ const pending = waitForDialogMutationState(window.document, () => window.document.querySelector('[role="dialog"]'), 50)
+ .then((value) => { outcome = value; return value; });
+
+ // When the clock advances to just before the deadline
+ t.mock.timers.tick(49);
+ await Promise.resolve();
+
+ // Then the native dialog remains awaited
+ assert.equal(outcome, 'pending');
+
+ // When the final virtual millisecond expires
+ t.mock.timers.tick(1);
+ const result = await pending;
+
+ // Then the final native DOM read returns no dialog at the exact deadline
+ assert.equal(result, null);
+ assert.equal(Date.now(), 1050);
});
diff --git a/test/unit/binance-orderbook-trade/cancel-dialog-decision.test.js b/test/unit/binance-orderbook-trade/cancel-dialog-decision.test.js
index c9a8b6f..dfa6854 100644
--- a/test/unit/binance-orderbook-trade/cancel-dialog-decision.test.js
+++ b/test/unit/binance-orderbook-trade/cancel-dialog-decision.test.js
@@ -15,38 +15,70 @@ function resolve(overrides = {}) {
});
}
-test('a pre-captured fast confirm is preserved after the dialog closes', () => {
- assert.equal(resolve({ seenDialog: true, action: 'confirmed' }), 'confirmed');
+test('user retains a captured confirmation after the dialog closes', () => {
+ // Given confirmation was captured before the native dialog disappeared
+ const state = { seenDialog: true, action: 'confirmed' };
+
+ // When the completed dialog decision is resolved
+ const decision = resolve(state);
+
+ // Then the native confirmation remains the completed outcome
+ assert.equal(decision, 'confirmed');
});
-test('cancel, Escape, backdrop, and empty-area closure resolve as cancelled', () => {
- assert.equal(resolve({ seenDialog: true, action: 'cancelled' }), 'cancelled');
- assert.equal(resolve({ seenDialog: true, action: null }), 'cancelled');
+test('user cancels when the dialog closes with a cancellation or without confirmation', () => {
+ // Given the seen dialog closes after cancellation or an unconfirmed dismissal
+ const states = [{ seenDialog: true, action: 'cancelled' }, { seenDialog: true, action: null }];
+
+ // When each dismissal is resolved
+ const decisions = states.map(resolve);
+
+ // Then neither dismissal authorizes cancellation of exchange orders
+ assert.deepEqual(decisions, ['cancelled', 'cancelled']);
});
-test('a visible dialog keeps waiting regardless of elapsed user decision time', () => {
- assert.equal(resolve({
+test('user can leave the native confirmation visible without a decision timeout', () => {
+ // Given a visible dialog has an earlier captured click and can remain open for an hour
+ const states = [{
seenDialog: true,
action: 'confirmed',
dialogVisible: true,
- }), 'waiting');
- assert.equal(resolve({
+ }, {
seenDialog: true,
action: 'confirmed',
dialogVisible: true,
nowMs: 3_600_000,
- }), 'waiting');
+ }];
+
+ // When the pending decision is read before and after that hour
+ const decisions = states.map(resolve);
+
+ // Then the dialog remains pending while Binance still displays it
+ assert.deepEqual(decisions, ['waiting', 'waiting']);
});
-test('page lifecycle abort is distinct from a dialog contract failure', () => {
- assert.equal(resolve({
+test('user sees an aborted decision when the page lifecycle ends', () => {
+ // Given the page is aborted with the native dialog still visible
+ const state = {
seenDialog: true,
dialogVisible: true,
aborted: true,
- }), 'aborted');
+ };
+
+ // When the dialog decision is resolved
+ const decision = resolve(state);
+
+ // Then the result identifies lifecycle abort instead of missing confirmation
+ assert.equal(decision, 'aborted');
});
-test('an unseen dialog fails only after its discovery deadline', () => {
- assert.equal(resolve(), 'waiting');
- assert.equal(resolve({ nowMs: 2_000 }), 'not_found');
+test('user sees a missing dialog only after its discovery deadline', () => {
+ // Given the dialog has never appeared before or exactly at its discovery deadline
+ const states = [{ nowMs: 1_999 }, { nowMs: 2_000 }];
+
+ // When discovery is evaluated at both deadline boundaries
+ const decisions = states.map(resolve);
+
+ // Then discovery stays pending before the deadline and fails exactly at it
+ assert.deepEqual(decisions, ['waiting', 'not_found']);
});
diff --git a/test/unit/binance-orderbook-trade/chart-marker-save-controller.test.js b/test/unit/binance-orderbook-trade/chart-marker-save-controller.test.js
index 9a6930b..9aba955 100644
--- a/test/unit/binance-orderbook-trade/chart-marker-save-controller.test.js
+++ b/test/unit/binance-orderbook-trade/chart-marker-save-controller.test.js
@@ -44,10 +44,15 @@ function fixture() {
get serializations() { return serializations; } };
}
-test('idle marker controller preserves synchronous callback, receiver, and return', () => {
+test("user sees that idle marker controller preserves synchronous callback, receiver, and return", () => {
+ // Given the native chart save controller and marker lifecycle are initialized
const f = fixture();
let seen;
+ // When the requested marker or save transition executes
const result = f.api.saveChart((state) => { seen = state; return 42; });
+
+
+ // Then sees that idle marker controller preserves synchronous callback, receiver, and return
assert.equal(result, 42);
assert.deepEqual(seen, f.state);
assert.equal(f.serializations, 1);
@@ -55,9 +60,11 @@ test('idle marker controller preserves synchronous callback, receiver, and retur
assert.equal(f.timers.size, 0);
});
-test('marker burst serializes once and delivers a separate complete snapshot to every callback', () => {
+test("user sees that marker burst serializes once and delivers a separate complete snapshot to every callback", () => {
+ // Given the native chart save controller and marker lifecycle are initialized
const f = fixture();
f.controller.beginMutation()();
+ // When the requested marker or save transition executes
f.advance(100);
const snapshots = [];
for (let i = 0; i < 100; i += 1) {
@@ -67,6 +74,7 @@ test('marker burst serializes once and delivers a separate complete snapshot to
value.drawings[0].color = `callback-${i}`;
}), undefined);
}
+ // Then sees that marker burst serializes once and delivers a separate complete snapshot to every callback
assert.equal(f.serializations, 0);
f.advance(150);
assert.equal(f.serializations, 1);
@@ -80,13 +88,16 @@ test('marker burst serializes once and delivers a separate complete snapshot to
assert.equal(f.timers.size, 0);
});
-test('callback errors do not skip later callbacks or interrupt explicit save options', () => {
+test("user sees that callback errors do not skip later callbacks or interrupt explicit save options", () => {
+ // Given the native chart save controller and marker lifecycle are initialized
const f = fixture();
f.controller.beginMutation()();
let completed = 0;
f.api.saveChart(() => { throw new Error('first callback failed'); });
+ // When the requested marker or save transition executes
f.api.saveChart(() => { completed += 1; });
const options = { includeDrawings: false };
+ // Then sees that callback errors do not skip later callbacks or interrupt explicit save options
assert.equal(f.api.saveChart(() => 'explicit-result', options), 'explicit-result');
assert.equal(completed, 1);
assert.equal(f.serializations, 2);
@@ -96,15 +107,18 @@ test('callback errors do not skip later callbacks or interrupt explicit save opt
assert.equal(f.errors[0].errors[0].message, 'first callback failed');
});
-test('foreign receiver, options and non-callback arguments stay synchronous', () => {
+test("user sees that foreign receiver, options and non-callback arguments stay synchronous", () => {
+ // Given the native chart save controller and marker lifecycle are initialized
const f = fixture();
for (const options of [{}, { includeDrawings: false }]) {
f.controller.beginMutation()();
assert.equal(f.api.saveChart(() => 7, options), 7);
assert.equal(f.calls.at(-1).options, options);
}
+ // When the requested marker or save transition executes
f.controller.beginMutation()();
const receiver = {};
+ // Then sees that foreign receiver, options and non-callback arguments stay synchronous
assert.equal(f.api.saveChart.call(receiver, () => 8), 8);
assert.equal(f.calls.at(-1).receiver, receiver);
f.controller.beginMutation()();
@@ -112,35 +126,46 @@ test('foreign receiver, options and non-callback arguments stay synchronous', ()
assert.equal(f.serializations, 4);
});
-test('base wrapper never captures or restores across an outer save owner', () => {
+test("user sees that base wrapper never captures or restores across an outer save owner", () => {
+ // Given the native chart save controller and marker lifecycle are initialized
const f = fixture();
const base = f.api.saveChart;
f.controller.beginMutation()();
f.api.saveChart(() => 1);
function outer(...args) { return base.apply(this, args); }
+ // When the requested marker or save transition executes
f.api.saveChart = outer;
+ // Then sees that base wrapper never captures or restores across an outer save owner
assert.equal(f.api.saveChart(() => 2), 2);
assert.equal(f.api.saveChart, outer);
assert.equal(f.serializations, 2);
assert.equal(f.controller.canMutate(), false);
});
-test('maximum burst window bounds serialization under a continuous event stream', () => {
+test("user sees that maximum burst window bounds serialization under a continuous event stream", () => {
+ // Given the native chart save controller and marker lifecycle are initialized
const f = fixture();
+ // When the requested marker or save transition executes
for (let i = 0; i < 10; i += 1) {
f.controller.beginMutation()();
f.api.saveChart(() => {});
f.advance(100);
}
+
+
+ // Then sees that maximum burst window bounds serialization under a continuous event stream
assert.equal(f.serializations, 1);
f.advance(50);
assert.equal(f.controller.getStats().busy, false);
});
-test('an explicit save cannot end the mutation tail before the native delayed callback', async () => {
+test("user sees that an explicit save cannot end the mutation tail before the native delayed callback", async () => {
+ // Given the native chart save controller and marker lifecycle are initialized
const f = fixture();
f.controller.beginMutation()();
+ // When the requested marker or save transition executes
f.advance(10);
+ // Then sees that an explicit save cannot end the mutation tail before the native delayed callback
assert.equal(f.api.saveChart(() => 3, {}), 3);
let starts = 0;
const drain = f.controller.runAfterIdle(() => { starts += 1; });
@@ -154,12 +179,17 @@ test('an explicit save cannot end the mutation tail before the native delayed ca
assert.equal(f.serializations, 2);
});
-test('drain blocks new mutations and waits for asynchronous creation and its delayed saves', async () => {
+test("user sees that drain blocks new mutations and waits for asynchronous creation and its delayed saves", async () => {
+ // Given the native chart save controller and marker lifecycle are initialized
const f = fixture();
const finish = f.controller.beginMutation();
let ownerStarted = false;
const drain = f.controller.runAfterIdle(() => { ownerStarted = true; return 17; });
- assert.equal(f.controller.canMutate(), false);
+ // When the requested marker or save transition executes
+ const observed = f.controller.canMutate();
+
+ // Then sees that drain blocks new mutations and waits for asynchronous creation and its delayed saves
+ assert.equal(observed, false);
f.advance(500);
await Promise.resolve();
assert.equal(ownerStarted, false);
@@ -177,14 +207,17 @@ test('drain blocks new mutations and waits for asynchronous creation and its del
assert.equal(f.timers.size, 0);
});
-test('stalled native creation rejects bounded drain without starting the outer action', async () => {
+test("user sees that stalled native creation rejects bounded drain without starting the outer action", async () => {
+ // Given the native chart save controller and marker lifecycle are initialized
const f = fixture();
const finish = f.controller.beginMutation();
let starts = 0;
const drain = f.controller.runAfterIdle(() => { starts += 1; });
const rejected = assert.rejects(drain, { name: 'TradingViewMarkerSaveDrainTimeoutError' });
f.advance(2000);
+ // When the requested marker or save transition executes
await rejected;
+ // Then sees that stalled native creation rejects bounded drain without starting the outer action
assert.equal(starts, 0);
finish();
f.advance(150);
@@ -192,10 +225,15 @@ test('stalled native creation rejects bounded drain without starting the outer a
assert.equal(f.timers.size, 0);
});
-test('one API installs one base wrapper and another API has independent state', () => {
+test("user sees that one API installs one base wrapper and another API has independent state", () => {
+ // Given the native chart save controller and marker lifecycle are initialized
const f = fixture();
const base = f.api.saveChart;
- assert.equal(subject.installTradingViewMarkerSaveController(f.api), f.controller);
+ // When the requested marker or save transition executes
+ const observed = subject.installTradingViewMarkerSaveController(f.api);
+
+ // Then sees that one API installs one base wrapper and another API has independent state
+ assert.equal(observed, f.controller);
assert.equal(f.api.saveChart, base);
const other = fixture();
f.controller.beginMutation()();
@@ -203,14 +241,17 @@ test('one API installs one base wrapper and another API has independent state',
f.advance(150);
});
-test('stop aborts a pending drain immediately without starting an outer owner', async () => {
+test("user sees that stop aborts a pending drain immediately without starting an outer owner", async () => {
+ // Given the native chart save controller and marker lifecycle are initialized
const f = fixture();
f.controller.beginMutation()();
const abort = new AbortController();
const reason = new Error('Stopped');
let starts = 0;
const drain = f.controller.runAfterIdle(() => { starts += 1; }, { signal: abort.signal });
+ // When the requested marker or save transition executes
abort.abort(reason);
+ // Then sees that stop aborts a pending drain immediately without starting an outer owner
await assert.rejects(drain, (error) => error === reason);
assert.equal(starts, 0);
assert.equal(f.controller.getStats().draining, 0);
diff --git a/test/unit/binance-orderbook-trade/chart-marker-save-entrypoints.test.js b/test/unit/binance-orderbook-trade/chart-marker-save-entrypoints.test.js
index d6f12fe..31f3935 100644
--- a/test/unit/binance-orderbook-trade/chart-marker-save-entrypoints.test.js
+++ b/test/unit/binance-orderbook-trade/chart-marker-save-entrypoints.test.js
@@ -39,10 +39,15 @@ function startupFixture() {
get starts() { return starts; } };
}
-test('production continuous startup waits for marker creation before installing its owner', async () => {
+test("user sees that production continuous startup waits for marker creation before installing its owner", async () => {
+ // Given the continuous action has a pending marker lifecycle
const f = startupFixture();
const finish = f.controller.beginMutation();
+ // When the production continuous entrypoint starts
const task = f.run(new AbortController().signal, 'BTRUSDT');
+
+
+ // Then sees that production continuous startup waits for marker creation before installing its owner
assert.equal(f.starts, 0);
finish();
assert.equal(await task, 'outer-owner');
@@ -51,25 +56,31 @@ test('production continuous startup waits for marker creation before installing
});
for (const change of ['changeSymbol', 'replaceChart']) {
- test(`production continuous startup rejects ${change} during marker drain`, async () => {
- const f = startupFixture();
+ test(`user sees that production continuous startup rejects ${change} during marker drain`, async () => {
+ // Given the continuous action has a pending marker lifecycle
+ const f = startupFixture();
const finish = f.controller.beginMutation();
const task = f.run(new AbortController().signal, 'BTRUSDT');
f[change]();
- finish();
- await assert.rejects(task, { name: 'LadderStoppedError' });
+ // When the production continuous entrypoint starts
+ finish();
+ // Then sees that production continuous startup rejects ${change} during marker drain
+ await assert.rejects(task, { name: 'LadderStoppedError' });
assert.equal(f.starts, 0);
assert.deepEqual(f.warnings, []);
});
}
-test('production continuous startup propagates Stop without optional-optimization fallback', async () => {
+test("user sees that production continuous startup propagates Stop without optional-optimization fallback", async () => {
+ // Given the continuous action has a pending marker lifecycle
const f = startupFixture();
const finish = f.controller.beginMutation();
const abort = new AbortController();
const reason = Object.assign(new Error('Stopped'), { name: 'LadderStoppedError' });
const task = f.run(abort.signal, 'BTRUSDT');
+ // When the production continuous entrypoint starts
abort.abort(reason);
+ // Then sees that production continuous startup propagates Stop without optional-optimization fallback
await assert.rejects(task, (error) => error === reason);
assert.equal(f.starts, 0);
assert.deepEqual(f.warnings, []);
diff --git a/test/unit/binance-orderbook-trade/chart-orders-recovery.test.js b/test/unit/binance-orderbook-trade/chart-orders-recovery.test.js
index cb4d067..9125afe 100644
--- a/test/unit/binance-orderbook-trade/chart-orders-recovery.test.js
+++ b/test/unit/binance-orderbook-trade/chart-orders-recovery.test.js
@@ -1,3 +1,4 @@
+import { captureThrownError } from '../../helpers/orderbook-migration-errors.js';
import test from 'node:test';
import assert from 'node:assert/strict';
@@ -6,9 +7,14 @@ import {
parseChartOrdersRecoveryRecord,
} from '../../../src/binance-orderbook-trade/core/chart-orders-recovery.js';
-test('creates and parses an exact chart orders reload recovery record', () => {
+test("user creates and parses an exact chart orders reload recovery record", () => {
+ // Given the persisted chart recovery record is available
const raw = createChartOrdersRecoveryRecord(1_000);
- assert.deepEqual(JSON.parse(raw), {
+ // When the chart recovery contract is evaluated
+ const observed = JSON.parse(raw);
+
+ // Then creates and parses an exact chart orders reload recovery record
+ assert.deepEqual(observed, {
version: 2,
originalChecked: true,
createdAtMs: 1_000,
@@ -19,8 +25,15 @@ test('creates and parses an exact chart orders reload recovery record', () => {
});
});
-test('distinguishes missing, invalid, and future recovery records', () => {
- assert.deepEqual(parseChartOrdersRecoveryRecord(null, 2_000), {
+test("user distinguishes missing, invalid, and future recovery records", () => {
+ // Given the persisted chart recovery record is available
+ const scenarioInputs = [null, 2_000];
+
+ // When the chart recovery contract is evaluated
+ const observed = parseChartOrdersRecoveryRecord(...scenarioInputs);
+
+ // Then distinguishes missing, invalid, and future recovery records
+ assert.deepEqual(observed, {
status: 'missing',
record: null,
});
@@ -46,19 +59,31 @@ test('distinguishes missing, invalid, and future recovery records', () => {
});
});
-test('valid recovery records do not expire before the hidden chart state is restored', () => {
+test("user sees that valid recovery records do not expire before the hidden chart state is restored", () => {
+ // Given the persisted chart recovery record is available
const oldRecord = { version: 2, originalChecked: true, createdAtMs: 1_000 };
- assert.deepEqual(parseChartOrdersRecoveryRecord(
+ // When the chart recovery contract is evaluated
+ const observed = parseChartOrdersRecoveryRecord(
JSON.stringify(oldRecord),
1_000 + (365 * 24 * 60 * 60 * 1000),
- ), {
+ );
+
+ // Then sees that valid recovery records do not expire before the hidden chart state is restored
+ assert.deepEqual(observed, {
status: 'valid',
record: oldRecord,
});
});
-test('recovery records reject extra fields and invalid timestamps', () => {
- assert.throws(() => createChartOrdersRecoveryRecord(Number.NaN), /图表委托线恢复时间无效/);
+test("user sees that recovery records reject extra fields and invalid timestamps", () => {
+ // Given the persisted chart recovery record is available
+ const scenarioInputs = [Number.NaN];
+
+ // When the chart recovery contract is evaluated
+ const observedFailure = captureThrownError(() => createChartOrdersRecoveryRecord(...scenarioInputs));
+
+ // Then sees that recovery records reject extra fields and invalid timestamps
+ assert.match(observedFailure.message, /图表委托线恢复时间无效/);
assert.throws(
() => parseChartOrdersRecoveryRecord('{}', Number.NaN),
/图表委托线恢复当前时间无效/,
diff --git a/test/unit/binance-orderbook-trade/decimal.test.js b/test/unit/binance-orderbook-trade/decimal.test.js
index f55167c..ebfa7c3 100644
--- a/test/unit/binance-orderbook-trade/decimal.test.js
+++ b/test/unit/binance-orderbook-trade/decimal.test.js
@@ -6,58 +6,167 @@ import {
ceilQtyByNotional,
compareDecimalStrings,
floorDecimalToStep,
+ formatDecimalParts,
+ isDecimalAtLeast,
+ isPositiveDecimalString,
maxDecimalString,
multiplyDecimalByInt,
multiplyDecimalByRatio,
normalizeDecimalString,
+ parseDecimalString,
subtractDecimalStrings,
} from '../../../src/binance-orderbook-trade/core/decimal.js';
-test('normalizes unsigned decimal strings without losing precision', () => {
- assert.equal(normalizeDecimalString('001.2300'), '1.23');
- assert.equal(normalizeDecimalString('0.000'), '0');
- assert.equal(normalizeDecimalString(0), '0');
- assert.equal(normalizeDecimalString('1,234.5000'), '1234.5');
- assert.equal(normalizeDecimalString('-1'), null);
- assert.equal(normalizeDecimalString('abc'), null);
+test('user keeps exact decimal digits while normalizing display values', () => {
+ // Given balances include padded, grouped, zero, and invalid unsigned values
+ const inputs = ['001.2300', '0.000', 0, '1,234.5000', '-1', 'abc', null, undefined];
+
+ // When each displayed balance is normalized
+ const results = inputs.map(normalizeDecimalString);
+
+ // Then valid balances retain precision and invalid balances stay unavailable
+ assert.deepEqual(results, ['1.23', '0', '0', '1234.5', null, null, null, null]);
+});
+
+test('user compares balances exactly across different decimal scales', () => {
+ // Given equal, greater, smaller, and unreadable balance pairs
+ const pairs = [['1.2', '1.20'], ['1.21', '1.2'], ['0.9', '1'], ['bad', '1'], ['1', 'bad']];
+
+ // When balance ordering is calculated
+ const comparisons = pairs.map(([left, right]) => compareDecimalStrings(left, right));
+
+ // Then trailing zeroes do not change equality and neither invalid side is ordered
+ assert.deepEqual(comparisons, [0, 1, -1, null, null]);
+});
+
+test('user adds and subtracts balances without floating point loss', () => {
+ // Given fractional balances and a subtraction exceeding the available balance
+ const additions = [['0.1', '0.02'], ['1.005', '2.005']];
+ const subtractions = [['1.00', '0.25'], ['0.25', '1.00'], ['1', '1']];
+
+ // When balances are added and debited
+ const added = additions.map(([left, right]) => addDecimalStrings(left, right));
+ const subtracted = subtractions.map(([left, right]) => subtractDecimalStrings(left, right));
+
+ // Then exact totals are returned and an overdraft is rejected
+ assert.deepEqual(added, ['0.12', '3.01']);
+ assert.deepEqual(subtracted, ['0.75', null, '0']);
+});
+
+test('user cannot calculate a balance change with an unreadable operand', () => {
+ // Given either side of a balance operation is missing or malformed
+ const pairs = [[null, '1'], ['1', null], ['bad', '1'], ['1', 'bad']];
+
+ // When addition and subtraction are requested for every pair
+ const additions = pairs.map(([left, right]) => addDecimalStrings(left, right));
+ const subtractions = pairs.map(([left, right]) => subtractDecimalStrings(left, right));
+
+ // Then no invalid balance becomes a usable amount
+ assert.deepEqual(additions, [null, null, null, null]);
+ assert.deepEqual(subtractions, [null, null, null, null]);
+});
+
+test('user rounds order quantities to the exact exchange step', () => {
+ // Given minimum notionals and quantities straddling exchange step boundaries
+ const notionals = [['5', '3', '0.1'], ['10', '4', '0.001'], ['0.001', '2', '1']];
+ const quantities = [['1.239', '0.01'], ['1.239', '0.1'], ['0.01', '1']];
+
+ // When minimum quantities are rounded up and available quantities rounded down
+ const minimums = notionals.map((args) => ceilQtyByNotional(...args));
+ const available = quantities.map((args) => floorDecimalToStep(...args));
+
+ // Then minimum notional is met without allocating unavailable fractional steps
+ assert.deepEqual(minimums, ['1.7', '2.5', '1']);
+ assert.deepEqual(available, ['1.23', '1.2', '0']);
});
-test('compares decimal strings at different scales', () => {
- assert.equal(compareDecimalStrings('1.2', '1.20'), 0);
- assert.equal(compareDecimalStrings('1.21', '1.2'), 1);
- assert.equal(compareDecimalStrings('0.9', '1'), -1);
- assert.equal(compareDecimalStrings('bad', '1'), null);
+test('user receives no quantity when exchange price or step information is invalid', () => {
+ // Given missing notional, price, quantity, or a zero exchange step
+ const notionals = [[null, '1', '1'], ['1', null, '1'], ['1', '1', null], ['1', '0', '1'], ['1', '1', '0']];
+ const quantities = [[null, '1'], ['1', null], ['1', '0']];
+
+ // When quantities are calculated from incomplete exchange rules
+ const minimums = notionals.map((args) => ceilQtyByNotional(...args));
+ const available = quantities.map((args) => floorDecimalToStep(...args));
+
+ // Then every unsupported calculation stays unavailable
+ assert.deepEqual(minimums, [null, null, null, null, null]);
+ assert.deepEqual(available, [null, null, null]);
});
-test('adds and subtracts decimal strings exactly', () => {
- assert.equal(addDecimalStrings('0.1', '0.02'), '0.12');
- assert.equal(addDecimalStrings('1.005', '2.005'), '3.01');
- assert.equal(subtractDecimalStrings('1.00', '0.25'), '0.75');
- assert.equal(subtractDecimalStrings('0.25', '1.00'), null);
+test('user multiplies quantities by exact integer and fractional ratios', () => {
+ // Given quantity multipliers include integers and ratios with repeating results
+ const integers = [['0.005', '3'], ['1.20', '10'], ['2', '3'], ['0.5', '2']];
+ const ratios = [['1.000', 1, 3], ['10', 3, 4], ['0.01', 60, 100]];
+
+ // When the configured quantity multiplier is applied
+ const multiplied = integers.map((args) => multiplyDecimalByInt(...args));
+ const divided = ratios.map((args) => multiplyDecimalByRatio(...args));
+
+ // Then decimal scale is preserved without binary rounding
+ assert.deepEqual(multiplied, ['0.015', '12', '6', '1']);
+ assert.deepEqual(divided, ['0.333', '7', '0.006']);
});
-test('rounds quantity requirements to exchange step size', () => {
- assert.equal(ceilQtyByNotional('5', '3', '0.1'), '1.7');
- assert.equal(ceilQtyByNotional('10', '4', '0.001'), '2.5');
- assert.equal(floorDecimalToStep('1.239', '0.01'), '1.23');
- assert.equal(floorDecimalToStep('1.239', '0.1'), '1.2');
+test('user applies a decimal percentage without converting balance arithmetic to floats', () => {
+ // Given small configured percentages of two account balances
+ const cases = [['5.64', 0.3, 100], ['10', 0.3, 100], ['1', '0.01', '0.2']];
+
+ // When those percentages are applied exactly
+ const amounts = cases.map((args) => multiplyDecimalByRatio(...args));
+
+ // Then fractional percentages retain all supported digits
+ assert.deepEqual(amounts, ['0.01692', '0.03', '0.05']);
});
-test('multiplies decimal strings by integer or ratio', () => {
- assert.equal(multiplyDecimalByInt('0.005', '3'), '0.015');
- assert.equal(multiplyDecimalByInt('1.20', '10'), '12');
- assert.equal(multiplyDecimalByRatio('1.000', 1, 3), '0.333');
- assert.equal(multiplyDecimalByRatio('10', 3, 4), '7');
- assert.equal(multiplyDecimalByRatio('0.01', 60, 100), '0.006');
+test('user cannot multiply quantities by missing or nonpositive multipliers', () => {
+ // Given invalid quantities, integer multipliers, and ratio denominators
+ const integers = [[null, '2'], ['bad', '2'], ['1', '0'], ['1', null], ['1', '0.5']];
+ const ratios = [[null, 1, 2], ['1', null, 2], ['1', 1, null], ['1', 0, 2], ['1', 1, 0]];
+
+ // When the invalid multiplier settings are evaluated
+ const multiplied = integers.map((args) => multiplyDecimalByInt(...args));
+ const divided = ratios.map((args) => multiplyDecimalByRatio(...args));
+
+ // Then none of the invalid settings yields a tradable quantity
+ assert.deepEqual(multiplied, [null, null, null, null, null]);
+ assert.deepEqual(divided, [null, null, null, null, null]);
});
-test('multiplies decimal strings by decimal ratio without floating point conversion', () => {
- assert.equal(multiplyDecimalByRatio('5.64', 0.3, 100), '0.01692');
- assert.equal(multiplyDecimalByRatio('10', 0.3, 100), '0.03');
+test('user selects the largest usable normalized decimal balance', () => {
+ // Given comparable balances and an unavailable alternative on either side
+ const pairs = [['1.20', '1.2'], ['1.19', '1.2'], [null, '0.0100'], ['0.0100', null], ['bad', '1'], ['1', 'bad']];
+
+ // When the maximum available balance is selected
+ const selected = pairs.map(([left, right]) => maxDecimalString(left, right));
+
+ // Then a valid alternative is retained and trailing zeroes are removed
+ assert.deepEqual(selected, ['1.2', '1.2', '0.01', '0.01', '1', '1']);
+});
+
+test('user preserves signed result formatting and exact integer digits', () => {
+ // Given parsed decimal digits and a signed arithmetic result
+ const input = ' 001.2300 ';
+ const parts = [[-12300n, 4], [-12n, 0], [0n, 3], [123n, 5]];
+
+ // When decimal parts are parsed and formatted for display
+ const parsed = parseDecimalString(input);
+ const formatted = parts.map(([digits, scale]) => formatDecimalParts(digits, scale));
+
+ // Then the scale and sign remain exact even below one unit
+ assert.deepEqual(parsed, { digits: 12300n, scale: 4 });
+ assert.deepEqual(formatted, ['-1.23', '-12', '0', '0.00123']);
});
-test('selects the maximum normalized decimal string', () => {
- assert.equal(maxDecimalString('1.20', '1.2'), '1.2');
- assert.equal(maxDecimalString('1.19', '1.2'), '1.2');
- assert.equal(maxDecimalString(null, '0.0100'), '0.01');
+test('user distinguishes a positive quantity from a quantity meeting the minimum', () => {
+ // Given zero, invalid, below-minimum, and exact-minimum values
+ const values = ['0', 'bad', '0.09', '0.10'];
+
+ // When positivity and the minimum quantity are checked
+ const positive = values.map(isPositiveDecimalString);
+ const meetsMinimum = values.map((value) => isDecimalAtLeast(value, '0.1'));
+
+ // Then zero and invalid values are rejected and the exact minimum is accepted
+ assert.deepEqual(positive, [false, false, true, true]);
+ assert.deepEqual(meetsMinimum, [false, false, false, true]);
});
diff --git a/test/unit/binance-orderbook-trade/depth-profile-book.test.js b/test/unit/binance-orderbook-trade/depth-profile-book.test.js
index 0b4f4d2..954e685 100644
--- a/test/unit/binance-orderbook-trade/depth-profile-book.test.js
+++ b/test/unit/binance-orderbook-trade/depth-profile-book.test.js
@@ -1,3 +1,4 @@
+import { captureThrownError } from '../../helpers/orderbook-migration-errors.js';
import test from 'node:test';
import assert from 'node:assert/strict';
@@ -32,10 +33,16 @@ function snapshot(overrides = {}) {
};
}
-test('buffers updates until a snapshot and applies the first covering event', () => {
+test("user buffers updates until a snapshot and applies the first covering event", () => {
+ // Given the symbol book and native depth messages are available
const book = createDepthProfileBook('BTCUSDT');
- assert.equal(pushDepthProfileUpdate(book, update()), false);
- assert.equal(applyDepthProfileSnapshot(book, snapshot()), true);
+ // When the snapshot or stream update is processed
+ const observed = pushDepthProfileUpdate(book, update());
+ const synchronized = applyDepthProfileSnapshot(book, snapshot());
+
+ // Then buffers updates until a snapshot and applies the first covering event
+ assert.equal(observed, false);
+ assert.equal(synchronized, true);
assert.equal(book.ready, true);
assert.equal(book.previousFinalUpdateId, 102);
@@ -43,20 +50,26 @@ test('buffers updates until a snapshot and applies the first covering event', ()
assert.equal(book.asks.get('101'), '4');
});
-test('drops stale buffered updates before the first snapshot-covering event', () => {
+test("user drops stale buffered updates before the first snapshot-covering event", () => {
+ // Given the symbol book and native depth messages are available
const book = createDepthProfileBook('BTCUSDT');
pushDepthProfileUpdate(book, update({ U: 90, u: 95, pu: 89 }));
+ // When the snapshot or stream update is processed
pushDepthProfileUpdate(book, update({ U: 99, u: 103, pu: 95 }));
+ const synchronized = applyDepthProfileSnapshot(book, snapshot({ lastUpdateId: 100 }));
- assert.equal(applyDepthProfileSnapshot(book, snapshot({ lastUpdateId: 100 })), true);
+ // Then drops stale buffered updates before the first snapshot-covering event
+ assert.equal(synchronized, true);
assert.equal(book.previousFinalUpdateId, 103);
});
-test('applies absolute quantities and removes zero-quantity levels', () => {
+test("user applies absolute quantities and removes zero-quantity levels", () => {
+ // Given the symbol book and native depth messages are available
const book = createDepthProfileBook('BTCUSDT');
pushDepthProfileUpdate(book, update());
applyDepthProfileSnapshot(book, snapshot());
+ // When the snapshot or stream update is processed
pushDepthProfileUpdate(book, update({
U: 103,
u: 104,
@@ -65,45 +78,53 @@ test('applies absolute quantities and removes zero-quantity levels', () => {
a: [['101', '8']],
}));
+ // Then applies absolute quantities and removes zero-quantity levels
assert.equal(book.bids.has('100'), false);
assert.equal(book.bids.get('98'), '7');
assert.equal(book.asks.get('101'), '8');
});
-test('rejects a sequence gap after synchronization', () => {
+test("user rejects a sequence gap after synchronization", () => {
+ // Given the symbol book and native depth messages are available
const book = createDepthProfileBook('BTCUSDT');
pushDepthProfileUpdate(book, update());
applyDepthProfileSnapshot(book, snapshot());
- assert.throws(
- () => pushDepthProfileUpdate(book, update({ U: 105, u: 106, pu: 104 })),
- DepthProfileSequenceError,
- );
+ // When the next stream event skips the synchronized sequence
+ const failure = captureThrownError(() => pushDepthProfileUpdate(book, update({ U: 105, u: 106, pu: 104 })));
+
+ // Then rejects a sequence gap after synchronization
+ assert.equal(failure instanceof DepthProfileSequenceError, true);
+ assert.equal(failure.message, 'Depth update sequence gap: expected pu 102, received 104');
});
-test('rejects a snapshot that cannot connect to buffered updates', () => {
+test("user rejects a snapshot that cannot connect to buffered updates", () => {
+ // Given the symbol book and native depth messages are available
const book = createDepthProfileBook('BTCUSDT');
pushDepthProfileUpdate(book, update({ U: 110, u: 112, pu: 109 }));
- assert.throws(
- () => applyDepthProfileSnapshot(book, snapshot({ lastUpdateId: 100 })),
- /Depth snapshot gap/,
- );
+ // When the native snapshot cannot cover the earliest buffered event
+ const failure = captureThrownError(() => applyDepthProfileSnapshot(book, snapshot({ lastUpdateId: 100 })));
+
+ // Then rejects a snapshot that cannot connect to buffered updates
+ assert.equal(failure instanceof DepthProfileSequenceError, true);
+ assert.equal(failure.message, 'Depth snapshot gap: snapshot 100, first update 110');
});
-test('rejects data for another symbol or a non-USD-M contract', () => {
+test("user rejects data for another symbol or a non-USD-M contract", () => {
+ // Given the symbol book and native depth messages are available
const book = createDepthProfileBook('BTCUSDT');
- assert.throws(
- () => pushDepthProfileUpdate(book, update({ s: 'ETHUSDT' })),
- /symbol mismatch/,
- );
- assert.throws(
- () => pushDepthProfileUpdate(book, update({ st: 2 })),
- /non-USD-M data/,
- );
+ // When the snapshot or stream update is processed
+ const observedFailure = captureThrownError(() => pushDepthProfileUpdate(book, update({ s: 'ETHUSDT' })));
+ const marketFailure = captureThrownError(() => pushDepthProfileUpdate(book, update({ st: 2 })));
+
+ // Then rejects data for another symbol or a non-USD-M contract
+ assert.match(observedFailure.message, /symbol mismatch/);
+ assert.equal(marketFailure.message, 'Depth profile received non-USD-M data: 2');
});
-test('builds a symmetric vertical price range with cumulative depth', () => {
+test("user builds a symmetric vertical price range with cumulative depth", () => {
+ // Given the symbol book and native depth messages are available
const book = createDepthProfileBook('BTCUSDT');
pushDepthProfileUpdate(book, update({
b: [['100', '2'], ['99', '3'], ['98', '5']],
@@ -111,8 +132,10 @@ test('builds a symmetric vertical price range with cumulative depth', () => {
}));
applyDepthProfileSnapshot(book, snapshot());
+ // When the snapshot or stream update is processed
const profile = buildDepthProfile(book);
+ // Then builds a symmetric vertical price range with cumulative depth
assert.equal(profile.midPrice, 100.5);
assert.equal(profile.minPrice, 98);
assert.equal(profile.maxPrice, 103);
@@ -121,16 +144,19 @@ test('builds a symmetric vertical price range with cumulative depth', () => {
assert.equal(profile.maxCumulative, 20);
});
-test('preserves every active price level accumulated from the native depth stream', () => {
+test("user preserves every active price level accumulated from the native depth stream", () => {
+ // Given the symbol book and native depth messages are available
const book = createDepthProfileBook('BTCUSDT');
- book.ready = true;
- for (let index = 0; index < 1001; index += 1) {
- book.bids.set(String(100 - index / 1000), '1');
- book.asks.set(String(101 + index / 1000), '1');
- }
+ applyDepthProfileSnapshot(book, snapshot({
+ bids: Array.from({ length: 1001 }, (_, index) => [String(100 - index / 1000), '1']),
+ asks: Array.from({ length: 1001 }, (_, index) => [String(101 + index / 1000), '1']),
+ }));
+ pushDepthProfileUpdate(book, update({ b: [], a: [] }));
+ // When the snapshot or stream update is processed
const profile = buildDepthProfile(book);
+ // Then preserves every active price level accumulated from the native depth stream
assert.equal(profile.bids.length, 1001);
assert.equal(profile.asks.length, 1001);
assert.equal(profile.bids.at(-1).price, 99);
@@ -140,11 +166,17 @@ test('preserves every active price level accumulated from the native depth strea
});
for (const symbol of ['龙虾USDT', '币安人生USDT', '4USDT', '1INCHUSDT', '1000龙虾USDT']) {
- test(`synchronizes ${symbol} without changing quantity or sequence semantics`, () => {
+ test(`user synchronizes ${symbol} without changing quantity or sequence semantics`, () => {
+ // Given the symbol book and native depth messages are available
const book = createDepthProfileBook(symbol);
- assert.equal(pushDepthProfileUpdate(book, update({ s: symbol })), false);
- assert.equal(applyDepthProfileSnapshot(book, snapshot()), true);
+ // When the snapshot or stream update is processed
+ const observed = pushDepthProfileUpdate(book, update({ s: symbol }));
+ const synchronized = applyDepthProfileSnapshot(book, snapshot());
const profile = buildDepthProfile(book);
+
+ // Then the exact symbol keeps its quantities and sequence ownership
+ assert.equal(observed, false);
+ assert.equal(synchronized, true);
assert.equal(profile.symbol, symbol);
assert.deepEqual(profile.bids.map(({ price, cumulative }) => ({ price, cumulative })), [
{ price: 100, cumulative: 2 }, { price: 99, cumulative: 5 },
@@ -156,3 +188,190 @@ for (const symbol of ['龙虾USDT', '币安人生USDT', '4USDT', '1INCHUSDT', '1
assert.throws(() => pushDepthProfileUpdate(book, update({ s: symbol, U: 105, u: 106, pu: 104 })), DepthProfileSequenceError);
});
}
+
+test('user synchronizes a snapshot that arrives before its first covering stream event', () => {
+ // Given a fresh symbol book receives its snapshot before the WebSocket update
+ const book = createDepthProfileBook('BTCUSDT');
+ const snapshotReady = applyDepthProfileSnapshot(book, snapshot());
+
+ // When the first stream event covers the snapshot update id
+ const updateReady = pushDepthProfileUpdate(book, update({ st: undefined }));
+ const profile = buildDepthProfile(book);
+
+ // Then the snapshot waits for synchronization and the covering event establishes exact quantities
+ assert.equal(snapshotReady, false);
+ assert.equal(updateReady, true);
+ assert.equal(book.previousFinalUpdateId, 102);
+ assert.equal(profile.bids[0].quantity, 2);
+ assert.equal(profile.asks[0].quantity, 4);
+});
+
+test('user drains consecutive buffered events while ignoring a duplicate final update', () => {
+ // Given the native stream queued a covering event, its duplicate, and the next update
+ const book = createDepthProfileBook('BTCUSDT');
+ pushDepthProfileUpdate(book, update());
+ pushDepthProfileUpdate(book, update({ U: 100, u: 102, pu: 99, b: [['100', '90']] }));
+ pushDepthProfileUpdate(book, update({ U: 103, u: 104, pu: 102, b: [['100', '7']], a: [['101', '8']] }));
+
+ // When the snapshot connects the buffered sequence
+ const ready = applyDepthProfileSnapshot(book, snapshot());
+ const profile = buildDepthProfile(book);
+
+ // Then the final event owns the quantities and no buffered messages remain
+ assert.equal(ready, true);
+ assert.equal(book.previousFinalUpdateId, 104);
+ assert.deepEqual(book.bufferedUpdates, []);
+ assert.equal(profile.bids[0].quantity, 7);
+ assert.equal(profile.asks[0].quantity, 8);
+});
+
+test('user discards an entirely stale buffer while waiting for a current covering event', () => {
+ // Given the native stream only buffered an event older than the coming snapshot
+ const book = createDepthProfileBook('BTCUSDT');
+ pushDepthProfileUpdate(book, update({ U: 90, u: 95, pu: 89 }));
+
+ // When the newer snapshot arrives without a covering update
+ const ready = applyDepthProfileSnapshot(book, snapshot());
+ const failure = captureThrownError(() => buildDepthProfile(book));
+
+ // Then stale events are discarded and the unconfirmed snapshot cannot be displayed
+ assert.equal(ready, false);
+ assert.deepEqual(book.bufferedUpdates, []);
+ assert.equal(book.previousFinalUpdateId, null);
+ assert.equal(failure.message, 'Depth profile book is not ready');
+});
+
+test('user ignores a stale update after synchronization without replacing current quantities', () => {
+ // Given the book already synchronized through update 102
+ const book = createDepthProfileBook('BTCUSDT');
+ applyDepthProfileSnapshot(book, snapshot());
+ pushDepthProfileUpdate(book, update());
+
+ // When a duplicate final update carries obsolete quantities and a stale predecessor
+ const ready = pushDepthProfileUpdate(book, update({ pu: 1, b: [['100', '90']], a: [['101', '91']] }));
+ const profile = buildDepthProfile(book);
+
+ // Then the synchronized id and exact quantities stay unchanged
+ assert.equal(ready, true);
+ assert.equal(book.previousFinalUpdateId, 102);
+ assert.equal(profile.bids[0].quantity, 2);
+ assert.equal(profile.asks[0].quantity, 4);
+});
+
+test('user receives a sequence error when the native update buffer exceeds 500 events', () => {
+ // Given 500 valid native updates are waiting for their first snapshot
+ const book = createDepthProfileBook('BTCUSDT');
+ for (let index = 0; index < 500; index += 1) pushDepthProfileUpdate(book, update());
+ const bufferedCount = book.bufferedUpdates.length;
+
+ // When the next native update exceeds the finite synchronization buffer
+ const failure = captureThrownError(() => pushDepthProfileUpdate(book, update()));
+
+ // Then the boundary is explicit and no unsynchronized book is reported ready
+ assert.equal(bufferedCount, 500);
+ assert.equal(failure instanceof DepthProfileSequenceError, true);
+ assert.equal(failure.name, 'DepthProfileSequenceError');
+ assert.equal(failure.message, 'Depth update buffer exceeded its limit');
+ assert.equal(book.ready, false);
+});
+
+test('user excludes zero-quantity snapshot levels before computing cumulative depth', () => {
+ // Given a snapshot includes deleted prices on both sides of the book
+ const book = createDepthProfileBook('BTCUSDT');
+ applyDepthProfileSnapshot(book, snapshot({
+ bids: [['100', '0'], ['99', '2']], asks: [['101', '0'], ['102', '3']],
+ }));
+
+ // When an empty covering event confirms the snapshot sequence
+ pushDepthProfileUpdate(book, update({ b: [], a: [] }));
+ const profile = buildDepthProfile(book);
+
+ // Then only active prices contribute to the displayed range and cumulative quantity
+ assert.deepEqual(profile.bids, [{ price: 99, quantity: 2, cumulative: 2 }]);
+ assert.deepEqual(profile.asks, [{ price: 102, quantity: 3, cumulative: 3 }]);
+ assert.equal(profile.maxCumulative, 3);
+});
+
+for (const symbol of ['', 'btcusdt', 'BTCUSDT\n']) {
+ test(`user rejects the invalid depth book symbol ${JSON.stringify(symbol)}`, () => {
+ // Given a symbol that does not satisfy the native contract
+ const input = symbol;
+
+ // When the source requests a book for that symbol
+ const failure = captureThrownError(() => createDepthProfileBook(input));
+
+ // Then the invalid ownership is rejected before any book is created
+ assert.equal(failure.message, 'Invalid depth profile symbol');
+ });
+}
+
+for (const { label, payload, expected } of [
+ { label: 'missing payload', payload: null, expected: 'Invalid depth profile snapshot' },
+ { label: 'primitive payload', payload: 42, expected: 'Invalid depth profile snapshot' },
+ { label: 'negative update id', payload: snapshot({ lastUpdateId: -1 }), expected: 'Invalid depth profile snapshot update id' },
+ { label: 'fractional update id', payload: snapshot({ lastUpdateId: 1.5 }), expected: 'Invalid depth profile snapshot update id' },
+ { label: 'missing bid levels', payload: snapshot({ bids: null }), expected: 'Invalid depth profile snapshot bids' },
+ { label: 'non-array level', payload: snapshot({ bids: [null] }), expected: 'Invalid depth profile snapshot bids level' },
+ { label: 'incomplete level', payload: snapshot({ asks: [['101']] }), expected: 'Invalid depth profile snapshot asks level' },
+ { label: 'zero price', payload: snapshot({ bids: [['0', '1']] }), expected: 'Invalid depth profile snapshot bids price' },
+ { label: 'non-numeric price', payload: snapshot({ asks: [['unknown', '1']] }), expected: 'Invalid depth profile snapshot asks price' },
+ { label: 'negative quantity', payload: snapshot({ bids: [['100', '-1']] }), expected: 'Invalid depth profile snapshot bids quantity' },
+ { label: 'infinite quantity', payload: snapshot({ asks: [['101', 'Infinity']] }), expected: 'Invalid depth profile snapshot asks quantity' },
+]) {
+ test(`user rejects a native snapshot with ${label}`, () => {
+ // Given a new book and an invalid native snapshot field
+ const book = createDepthProfileBook('BTCUSDT');
+
+ // When the snapshot is parsed through the public book operation
+ const failure = captureThrownError(() => applyDepthProfileSnapshot(book, payload));
+
+ // Then the precise contract failure leaves the book unsynchronized and empty
+ assert.equal(failure.message, expected);
+ assert.equal(book.ready, false);
+ assert.equal(book.bids.size, 0);
+ assert.equal(book.asks.size, 0);
+ assert.equal(book.snapshotUpdateId, null);
+ });
+}
+
+for (const { label, payload, expected } of [
+ { label: 'missing payload', payload: null, expected: 'Invalid depth profile update' },
+ { label: 'primitive payload', payload: 'depthUpdate', expected: 'Invalid depth profile update' },
+ { label: 'other event type', payload: update({ e: 'bookTicker' }), expected: 'Invalid depth profile update' },
+ { label: 'negative first id', payload: update({ U: -1 }), expected: 'Invalid depth profile first update id' },
+ { label: 'fractional final id', payload: update({ u: 102.5 }), expected: 'Invalid depth profile final update id' },
+ { label: 'unsafe predecessor id', payload: update({ pu: Number.MAX_SAFE_INTEGER + 1 }), expected: 'Invalid depth profile previous final update id' },
+]) {
+ test(`user rejects a native depth update with ${label}`, () => {
+ // Given a new book and an invalid native stream event
+ const book = createDepthProfileBook('BTCUSDT');
+
+ // When the stream update is parsed through the public operation
+ const failure = captureThrownError(() => pushDepthProfileUpdate(book, payload));
+
+ // Then the field failure cannot enter the synchronization buffer
+ assert.equal(failure.message, expected);
+ assert.deepEqual(book.bufferedUpdates, []);
+ assert.equal(book.ready, false);
+ });
+}
+
+for (const { label, bids, asks, expected } of [
+ { label: 'missing bids', bids: [], asks: [['101', '1']], expected: 'Depth profile requires bids and asks' },
+ { label: 'missing asks', bids: [['100', '1']], asks: [], expected: 'Depth profile requires bids and asks' },
+ { label: 'zero price range', bids: [['100', '1']], asks: [['100', '1']], expected: 'Depth profile price range is empty' },
+]) {
+ test(`user cannot display a synchronized depth profile with ${label}`, () => {
+ // Given valid native messages produce an unusable visible price range
+ const book = createDepthProfileBook('BTCUSDT');
+ applyDepthProfileSnapshot(book, snapshot({ bids, asks }));
+ pushDepthProfileUpdate(book, update({ b: [], a: [] }));
+
+ // When the visualization requests the confirmed depth profile
+ const failure = captureThrownError(() => buildDepthProfile(book));
+
+ // Then the unusable range is rejected explicitly despite a connected sequence
+ assert.equal(book.ready, true);
+ assert.equal(failure.message, expected);
+ });
+}
diff --git a/test/unit/binance-orderbook-trade/depth-profile-render-cycle.test.js b/test/unit/binance-orderbook-trade/depth-profile-render-cycle.test.js
index e2845d1..1b38b45 100644
--- a/test/unit/binance-orderbook-trade/depth-profile-render-cycle.test.js
+++ b/test/unit/binance-orderbook-trade/depth-profile-render-cycle.test.js
@@ -66,29 +66,38 @@ function harness() {
return { context, geometryReads, painted, view, setHeight: height => { nextHeight = height; } };
}
-test('depth synchronization measures geometry once and paints that exact snapshot', () => {
+test("user sees that depth synchronization measures geometry once and paints that exact snapshot", () => {
+ // Given the chart frame and depth view are mounted
const h = harness();
+ // When the depth render cycle executes
h.context.syncDepthProfile();
+ // Then sees that depth synchronization measures geometry once and paints that exact snapshot
assert.equal(h.geometryReads.length, 1);
assert.equal(h.painted.length, 1);
assert.equal(h.painted[0], h.geometryReads[0]);
assert.equal(h.painted[0].height, 400);
});
-test('the next independent depth render samples changed geometry again', () => {
+test("user sees that the next independent depth render samples changed geometry again", () => {
+ // Given the chart frame and depth view are mounted
const h = harness();
h.context.syncDepthProfile();
h.setHeight(600);
+ // When the depth render cycle executes
h.context.renderDepthProfileUi();
+ // Then sees that the next independent depth render samples changed geometry again
assert.equal(h.geometryReads.length, 2);
assert.deepEqual(h.painted.map(geometry => geometry.height), [400, 600]);
assert.equal(h.painted[1], h.geometryReads[1]);
});
-test('unavailable geometry, detached view and hidden documents do not paint', () => {
+test("user sees that unavailable geometry, detached view and hidden documents do not paint", () => {
+ // Given the chart frame and depth view are mounted
const h = harness();
h.setHeight(null);
+ // When the depth render cycle executes
h.context.syncDepthProfile();
+ // Then sees that unavailable geometry, detached view and hidden documents do not paint
assert.equal(h.geometryReads.length, 1);
assert.equal(h.context.depthProfileView, null);
assert.equal(h.painted.length, 0);
diff --git a/test/unit/binance-orderbook-trade/depth-profile-session.test.js b/test/unit/binance-orderbook-trade/depth-profile-session.test.js
index 2786a64..57b897b 100644
--- a/test/unit/binance-orderbook-trade/depth-profile-session.test.js
+++ b/test/unit/binance-orderbook-trade/depth-profile-session.test.js
@@ -1,16 +1,19 @@
import test from 'node:test';
import assert from 'node:assert/strict';
+import { captureThrownError } from '../../helpers/orderbook-migration-errors.js';
import { createDepthProfileSession } from '../../../src/binance-orderbook-trade/core/depth-profile-session.js';
class FakeNativeDepthSource {
constructor() {
this.subscriptions = [];
+ this.unsubscribeCalls = 0;
}
subscribe(subscription) {
this.subscriptions.push(subscription);
return () => {
+ this.unsubscribeCalls += 1;
this.subscriptions = this.subscriptions.filter((item) => item !== subscription);
};
}
@@ -24,7 +27,8 @@ class FakeNativeDepthSource {
}
}
-test('subscribes to the existing Binance native depth source', () => {
+test("user subscribes to the existing Binance native depth source", () => {
+ // Given the native source and symbol callbacks are configured
const statuses = [];
const profiles = [];
const source = new FakeNativeDepthSource();
@@ -37,8 +41,10 @@ test('subscribes to the existing Binance native depth source', () => {
session.start();
source.status({ symbol: 'BTCUSDT', status: 'synchronizing', detail: '' });
+ // When the depth session lifecycle advances
source.profile({ symbol: 'BTCUSDT', bids: [], asks: [] });
+ // Then subscribes to the existing Binance native depth source
assert.equal(profiles.length, 1);
assert.equal(profiles[0].symbol, 'BTCUSDT');
assert.equal(statuses.at(-1).status, 'synchronizing');
@@ -47,7 +53,8 @@ test('subscribes to the existing Binance native depth source', () => {
assert.equal(session.isActive(), false);
});
-test('stopped sessions ignore later native source events', () => {
+test("user stops receiving later native source events after ending a session", () => {
+ // Given the native source and symbol callbacks are configured
const profiles = [];
const source = new FakeNativeDepthSource();
const session = createDepthProfileSession({
@@ -59,11 +66,14 @@ test('stopped sessions ignore later native source events', () => {
session.start();
session.stop();
+ // When the depth session lifecycle advances
source.profile({ symbol: 'BTCUSDT', bids: [], asks: [] });
+ // Then stopped sessions ignore later native source events
assert.equal(profiles.length, 0);
});
-test('rejects mismatched native profile symbols', () => {
+test("user rejects mismatched native profile symbols", () => {
+ // Given the native source and symbol callbacks are configured
const source = new FakeNativeDepthSource();
const session = createDepthProfileSession({
symbol: 'BTCUSDT',
@@ -73,13 +83,17 @@ test('rejects mismatched native profile symbols', () => {
});
session.start();
- assert.throws(
- () => source.profile({ symbol: 'ETHUSDT', bids: [], asks: [] }),
- /symbol mismatch/,
- );
+
+ // When the source publishes another symbol through the active subscription
+ const failure = captureThrownError(() => source.profile({ symbol: 'ETHUSDT', bids: [], asks: [] }));
+
+ // Then rejects mismatched native profile symbols
+ assert.equal(failure.message, 'Depth profile profile symbol mismatch: expected BTCUSDT, received ETHUSDT');
+ session.stop();
});
-test('rejects duplicate starts', () => {
+test("user rejects duplicate starts", () => {
+ // Given the native source and symbol callbacks are configured
const source = new FakeNativeDepthSource();
const session = createDepthProfileSession({
symbol: 'BTCUSDT',
@@ -89,18 +103,28 @@ test('rejects duplicate starts', () => {
});
session.start();
- assert.throws(() => session.start(), /already started/);
+
+ // When the consumer starts the same active session again
+ const failure = captureThrownError(() => session.start());
+
+ // Then rejects duplicate starts
+ assert.equal(failure.message, 'Depth profile session already started');
+ assert.equal(source.subscriptions.length, 1);
+ session.stop();
});
for (const symbol of ['龙虾USDT', '币安人生USDT', '4USDT']) {
- test(`subscribes to ${symbol} and preserves exact symbol ownership`, () => {
+ test(`user subscribes to ${symbol} and preserves exact symbol ownership`, () => {
+ // Given the native source and symbol callbacks are configured
const source = new FakeNativeDepthSource();
const profiles = [];
const statuses = [];
const session = createDepthProfileSession({
symbol, source, onProfile: (profile) => profiles.push(profile), onStatus: (status) => statuses.push(status),
});
+ // When the depth session lifecycle advances
session.start();
+ // Then the subscription and status keep the full symbol unchanged
assert.equal(source.subscriptions.length, 1);
assert.equal(source.subscriptions[0].symbol, symbol);
assert.deepEqual(statuses, [{ symbol, status: 'connecting', detail: '' }]);
@@ -112,3 +136,164 @@ for (const symbol of ['龙虾USDT', '币安人生USDT', '4USDT']) {
assert.equal(source.subscriptions.length, 0);
});
}
+
+test('user receives fixture source events by identity and removes only the unsubscribed consumer', () => {
+ // Given two independent subscriptions share the native-source boundary fixture
+ const source = new FakeNativeDepthSource();
+ const firstEvents = [];
+ const secondEvents = [];
+ const first = {
+ symbol: 'BTCUSDT',
+ onProfile: (value) => firstEvents.push(value),
+ onStatus: (value) => firstEvents.push(value),
+ };
+ const second = {
+ symbol: 'BTCUSDT',
+ onProfile: (value) => secondEvents.push(value),
+ onStatus: (value) => secondEvents.push(value),
+ };
+ const unsubscribeFirst = source.subscribe(first);
+ source.subscribe(second);
+ const profile = { symbol: 'BTCUSDT', bids: [{ price: 100, cumulative: 2 }], asks: [{ price: 101, cumulative: 3 }] };
+ const status = { symbol: 'BTCUSDT', status: 'ready', detail: '' };
+
+ // When both receive a profile and the first unsubscribes before the status event
+ source.profile(profile);
+ unsubscribeFirst();
+ source.status(status);
+
+ // Then event identity is preserved and the unrelated subscriber remains active
+ assert.deepEqual(firstEvents, [profile]);
+ assert.deepEqual(secondEvents, [profile, status]);
+ assert.equal(firstEvents[0], profile);
+ assert.equal(secondEvents[0], profile);
+ assert.equal(secondEvents[1], status);
+ assert.deepEqual(source.subscriptions, [second]);
+ assert.equal(source.unsubscribeCalls, 1);
+});
+
+test('user ignores cached native callbacks after a depth session stops', () => {
+ // Given the native source may already have queued callbacks for its subscription
+ const source = new FakeNativeDepthSource();
+ const profiles = [];
+ const statuses = [];
+ const session = createDepthProfileSession({
+ symbol: 'BTCUSDT', source,
+ onProfile: (value) => profiles.push(value),
+ onStatus: (value) => statuses.push(value),
+ });
+ session.start();
+ const cachedSubscription = source.subscriptions[0];
+ session.stop();
+
+ // When already queued profile and status callbacks arrive after cleanup
+ cachedSubscription.onProfile({ symbol: 'BTCUSDT', bids: [], asks: [] });
+ cachedSubscription.onStatus({ symbol: 'BTCUSDT', status: 'ready', detail: '' });
+ cachedSubscription.onProfile(null);
+ cachedSubscription.onStatus(null);
+
+ // Then stopped callbacks cannot publish or validate obsolete page data
+ assert.equal(session.isActive(), false);
+ assert.deepEqual(profiles, []);
+ assert.deepEqual(statuses, [{ symbol: 'BTCUSDT', status: 'connecting', detail: '' }]);
+ assert.equal(source.subscriptions.length, 0);
+ assert.equal(source.unsubscribeCalls, 1);
+});
+
+test('user can stop before starting and repeatedly stop without duplicating unsubscribe work', () => {
+ // Given an initialized depth session has not started its native subscription
+ const source = new FakeNativeDepthSource();
+ const statuses = [];
+ const session = createDepthProfileSession({
+ symbol: 'BTCUSDT', source, onProfile() {}, onStatus: (value) => statuses.push(value),
+ });
+
+ // When cleanup runs before startup and twice after a normal start
+ session.stop();
+ const callsBeforeStart = source.unsubscribeCalls;
+ session.start();
+ const activeAfterStart = session.isActive();
+ session.stop();
+ session.stop();
+
+ // Then only the active subscription is removed and cleanup finishes inactive
+ assert.equal(callsBeforeStart, 0);
+ assert.equal(activeAfterStart, true);
+ assert.equal(session.isActive(), false);
+ assert.equal(source.unsubscribeCalls, 1);
+ assert.equal(source.subscriptions.length, 0);
+ assert.deepEqual(statuses, [{ symbol: 'BTCUSDT', status: 'connecting', detail: '' }]);
+});
+
+for (const { label, value, expected } of [
+ { label: 'another symbol', value: { symbol: 'ETHUSDT', status: 'ready', detail: '' }, expected: 'ETHUSDT' },
+ { label: 'missing status', value: null, expected: 'undefined' },
+]) {
+ test(`user rejects ${label} delivered as an active session status`, () => {
+ // Given a BTC session is subscribed and has only its initial connecting status
+ const source = new FakeNativeDepthSource();
+ const statuses = [];
+ const session = createDepthProfileSession({
+ symbol: 'BTCUSDT', source, onProfile() {}, onStatus: (status) => statuses.push(status),
+ });
+ session.start();
+
+ // When the native source violates the status symbol contract
+ const failure = captureThrownError(() => source.status(value));
+
+ // Then mismatched status data is rejected before reaching the visualization
+ assert.equal(failure.message, `Depth profile status symbol mismatch: expected BTCUSDT, received ${expected}`);
+ assert.deepEqual(statuses, [{ symbol: 'BTCUSDT', status: 'connecting', detail: '' }]);
+ session.stop();
+ });
+}
+
+for (const { label, changes, expected } of [
+ { label: 'invalid symbol', changes: { symbol: 'btcusdt' }, expected: 'Invalid depth profile session symbol' },
+ { label: 'missing source', changes: { source: null }, expected: 'Invalid depth profile source' },
+ { label: 'primitive source', changes: { source: 42 }, expected: 'Invalid depth profile source' },
+ { label: 'missing subscriber', changes: { source: {} }, expected: 'Invalid depth profile source subscriber' },
+ { label: 'missing profile listener', changes: { onProfile: null }, expected: 'Invalid depth profile profile listener' },
+ { label: 'missing status listener', changes: { onStatus: null }, expected: 'Invalid depth profile status listener' },
+]) {
+ test(`user rejects session options with ${label} before subscribing`, () => {
+ // Given otherwise valid dependencies contain one invalid session contract field
+ const source = new FakeNativeDepthSource();
+ const options = { symbol: 'BTCUSDT', source, onProfile() {}, onStatus() {}, ...changes };
+
+ // When the consumer creates the session
+ const failure = captureThrownError(() => createDepthProfileSession(options));
+
+ // Then the field-specific error occurs before any native source subscription
+ assert.equal(failure.message, expected);
+ assert.equal(source.subscriptions.length, 0);
+ });
+}
+
+test('user cannot create a depth session without options', () => {
+ // Given the caller has not provided a session configuration
+ const options = undefined;
+
+ // When session initialization validates its symbol ownership
+ const failure = captureThrownError(() => createDepthProfileSession(options));
+
+ // Then the missing symbol is rejected explicitly
+ assert.equal(failure.message, 'Invalid depth profile session symbol');
+});
+
+test('user receives an explicit error when the native source does not return unsubscribe', () => {
+ // Given a broken source accepts subscriptions without providing its cleanup function
+ const subscriptions = [];
+ const source = { subscribe(value) { subscriptions.push(value); return null; } };
+ const session = createDepthProfileSession({ symbol: 'BTCUSDT', source, onProfile() {}, onStatus() {} });
+
+ // When the session starts against that invalid source boundary
+ const failure = captureThrownError(() => session.start());
+ session.stop();
+
+ // Then the invalid cleanup contract is reported after exactly one subscribe call
+ assert.equal(failure.message, 'Invalid depth profile unsubscribe function');
+ assert.equal(subscriptions.length, 1);
+ assert.equal(subscriptions[0].symbol, 'BTCUSDT');
+ assert.equal(session.isActive(), false);
+});
diff --git a/test/unit/binance-orderbook-trade/interaction-feedback.test.js b/test/unit/binance-orderbook-trade/interaction-feedback.test.js
index 9f1cdf6..6febf47 100644
--- a/test/unit/binance-orderbook-trade/interaction-feedback.test.js
+++ b/test/unit/binance-orderbook-trade/interaction-feedback.test.js
@@ -6,12 +6,19 @@ import {
remainingInteractionFeedbackMs,
} from '../../../src/binance-orderbook-trade/core/interaction-feedback.js';
-test('calculates only the remaining interaction feedback duration', () => {
- assert.equal(remainingInteractionFeedbackMs({
+test("user calculates only the remaining interaction feedback duration", () => {
+ // Given the task and its visible feedback window are configured
+ const scenarioInputs = [{
startedAtMs: 100,
nowMs: 124,
minimumMs: 240,
- }), 216);
+ }];
+
+ // When the task completion time is evaluated
+ const observed = remainingInteractionFeedbackMs(...scenarioInputs);
+
+ // Then calculates only the remaining interaction feedback duration
+ assert.equal(observed, 216);
assert.equal(remainingInteractionFeedbackMs({
startedAtMs: 100,
nowMs: 400,
@@ -19,7 +26,8 @@ test('calculates only the remaining interaction feedback duration', () => {
}), 0);
});
-test('keeps an immediate failure pending until its feedback window is visible', async () => {
+test("user keeps an immediate failure pending until its feedback window is visible", async () => {
+ // Given the task and its visible feedback window are configured
const expectedError = new Error('insufficient funds');
let releaseDelay;
let requestedDelayMs = null;
@@ -42,8 +50,10 @@ test('keeps an immediate failure pending until its feedback window is visible',
);
await Promise.resolve();
+ // When the task completion time is evaluated
await Promise.resolve();
+ // Then keeps an immediate failure pending until its feedback window is visible
assert.equal(requestedDelayMs, 216);
assert.equal(settled, false);
@@ -52,8 +62,10 @@ test('keeps an immediate failure pending until its feedback window is visible',
assert.equal(settled, true);
});
-test('does not delay a task that already exceeded the feedback window', async () => {
+test("user does not delay a task that already exceeded the feedback window", async () => {
+ // Given the task and its visible feedback window are configured
let delayCalls = 0;
+ // When the task completion time is evaluated
const value = await keepInteractionFeedbackVisible(Promise.resolve('done'), {
startedAtMs: 100,
minimumMs: 240,
@@ -61,6 +73,7 @@ test('does not delay a task that already exceeded the feedback window', async ()
delay: async () => { delayCalls += 1; },
});
+ // Then does not delay a task that already exceeded the feedback window
assert.equal(value, 'done');
assert.equal(delayCalls, 0);
});
diff --git a/test/unit/binance-orderbook-trade/ladder-options.test.js b/test/unit/binance-orderbook-trade/ladder-options.test.js
index 777f470..e898756 100644
--- a/test/unit/binance-orderbook-trade/ladder-options.test.js
+++ b/test/unit/binance-orderbook-trade/ladder-options.test.js
@@ -1,6 +1,8 @@
-import { readFile } from 'node:fs/promises';
+import { captureThrownError } from '../../helpers/orderbook-migration-errors.js';
import test from 'node:test';
import assert from 'node:assert/strict';
+import { createLadderOptionHarness } from '../../helpers/orderbook-migration-ladder-options.js';
+import { PANEL_COPY, formatLocalizedText, localizedText } from '../../../src/binance-orderbook-trade/contracts/panel-copy.js';
import {
isModeSymbolOptionStorageKey,
@@ -10,8 +12,6 @@ import {
saveModeSymbolPrecisionNumberOption,
} from '../../../src/binance-orderbook-trade/core/panel-options.js';
-const source = await readFile(new URL('../../../src/binance-orderbook-trade/index.user.js', import.meta.url), 'utf8');
-
const MODE_KEYS = {
OPEN: 'jh_binance_ladder_open_levels',
CLOSE: 'jh_binance_ladder_close_levels',
@@ -40,32 +40,49 @@ function createStorage() {
};
}
-function readConstArray(name) {
- const match = new RegExp(`const ${name} = \\[([^\\]]+)\\];`).exec(source);
- assert.ok(match, `${name} should be defined`);
- return match[1].split(',').map((value) => Number(value.trim()));
-}
-
-function readConstNumber(name) {
- const match = new RegExp(`const ${name} = ([0-9.]+);`).exec(source);
- assert.ok(match, `${name} should be defined`);
- return Number(match[1]);
-}
-
-test('ladder percent options match configured open and close presets', () => {
- assert.deepEqual(readConstArray('LADDER_OPEN_PERCENTS'), [2, 10, 30, 50, 70]);
- assert.deepEqual(readConstArray('LADDER_CLOSE_PERCENTS'), [0.3, 1, 5, 10, 30]);
+test('user can save and restore each supported open and close percentage', (t) => {
+ // Given native symbol and precision context and the supported choices for each mode
+ const f = createLadderOptionHarness();
+ t.after(() => f.close());
+ const openChoices = [2, 10, 30, 50, 70];
+ const closeChoices = [0.3, 1, 5, 10, 30];
+
+ // When each choice passes through the real preference setter and getter
+ const openResults = openChoices.map((value) => {
+ const saved = f.context.setLadderOpenPercent(value);
+ return { saved, restored: f.context.getLadderOpenPercent() };
+ });
+ const closeResults = closeChoices.map((value) => {
+ const saved = f.context.setLadderClosePercent(value);
+ return { saved, restored: f.context.getLadderClosePercent() };
+ });
+
+ // Then every supported value round-trips and the final choices remain mode-scoped
+ assert.deepEqual(openResults, [
+ { saved: true, restored: 2 }, { saved: true, restored: 10 }, { saved: true, restored: 30 },
+ { saved: true, restored: 50 }, { saved: true, restored: 70 },
+ ]);
+ assert.deepEqual(closeResults, [
+ { saved: true, restored: 0.3 }, { saved: true, restored: 1 }, { saved: true, restored: 5 },
+ { saved: true, restored: 10 }, { saved: true, restored: 30 },
+ ]);
+ assert.equal(f.storage.getItem('jh_binance_ladder_open_percent:BTCUSDT:0.01'), '70');
+ assert.equal(f.storage.getItem('jh_binance_ladder_close_percent:BTCUSDT:0.01'), '30');
+ assert.equal(f.storage.length, 2);
});
-test('retired close 100 percent profiles explicitly migrate to the close default', () => {
+test("user sees that retired close 100 percent profiles explicitly migrate to the close default", () => {
+ // Given the symbol mode precision and saved ladder preferences are available
const storage = createStorage();
const percentKeys = {
OPEN: 'jh_binance_ladder_open_percent',
CLOSE: 'jh_binance_ladder_close_percent',
};
const options = [0.3, 1, 5, 10, 30];
+ // When the ladder preference contract is evaluated
storage.setItem('jh_binance_ladder_close_percent:BTCUSDT:0.01', '100');
+ // Then sees that retired close 100 percent profiles explicitly migrate to the close default
assert.equal(
migrateModeSymbolPrecisionNumberOption(
storage,
@@ -86,13 +103,13 @@ test('retired close 100 percent profiles explicitly migrate to the close default
assert.deepEqual(storage.entries(), [
['jh_binance_ladder_close_percent:BTCUSDT:0.01', '0.3'],
]);
- assert.doesNotMatch(source, /平仓量 100% 已调整为/);
});
-test('retired option migration rejects an unsupported replacement', () => {
+test("user sees that retired option migration rejects an unsupported replacement", () => {
+ // Given the symbol mode precision and saved ladder preferences are available
const storage = createStorage();
- assert.throws(
- () => migrateModeSymbolPrecisionNumberOption(
+ // When the ladder preference contract is evaluated
+ const observedFailure = captureThrownError(() => migrateModeSymbolPrecisionNumberOption(
storage,
MODE_KEYS,
'CLOSE',
@@ -101,28 +118,58 @@ test('retired option migration rejects an unsupported replacement', () => {
100,
0.3,
[1, 5, 10],
- ),
- /替换选项无效：0\.3/,
- );
+ ));
+
+ // Then sees that retired option migration rejects an unsupported replacement
+ assert.match(observedFailure.message, /替换选项无效：0\.3/);
});
-test('ladder default percents are available options', () => {
- assert.equal(readConstArray('LADDER_OPEN_PERCENTS').includes(readConstNumber('DEFAULT_LADDER_OPEN_PERCENT')), true);
- assert.equal(readConstArray('LADDER_CLOSE_PERCENTS').includes(readConstNumber('DEFAULT_LADDER_CLOSE_PERCENT')), true);
+test('user sees exactly one default percentage selected in each native mode', (t) => {
+ // Given a fresh preference store and both native trading modes
+ const f = createLadderOptionHarness();
+ t.after(() => f.close());
+ const rows = ['OPEN', 'CLOSE'].map(() => f.document.createElement('section'));
+
+ // When the production option renderer loads and displays each mode's defaults
+ for (const [index, mode] of ['OPEN', 'CLOSE'].entries()) {
+ rows[index].innerHTML = f.context.getLadderControlSections(mode, null, 'BTCUSDT', '0.01').optionRows.join('');
+ }
+
+ // Then the default choice exists once and is visibly selected among all five choices
+ const percentButtons = rows.map((row) => Array.from(row.querySelectorAll('[data-ladder-group="percent"]')));
+ assert.deepEqual(percentButtons.map((buttons) => buttons.length), [5, 5]);
+ assert.deepEqual(percentButtons.map((buttons) => buttons
+ .filter((button) => button.style.background === 'var(--color-BadgeBg)')
+ .map((button) => button.textContent)), [['2%'], ['0.3%']]);
});
-test('ladder default values match the per-symbol presets', () => {
- assert.equal(readConstNumber('DEFAULT_LADDER_OPEN_PERCENT'), 2);
- assert.equal(readConstNumber('DEFAULT_LADDER_CLOSE_PERCENT'), 0.3);
- assert.equal(readConstNumber('DEFAULT_LADDER_LEVELS'), 5);
- assert.equal(readConstNumber('DEFAULT_LADDER_STEP'), 5);
+test('user receives the initial mode-specific plan options without saving defaults', (t) => {
+ // Given a newly visited symbol has no saved ladder preferences
+ const f = createLadderOptionHarness();
+ t.after(() => f.close());
+
+ // When the production preference reader captures each mode's plan options
+ const defaults = ['OPEN', 'CLOSE'].map((mode) =>
+ f.context.readLadderOptionContext({ mode }, 'BTCUSDT', '0.01'));
+
+ // Then each plan receives its initial percentage, order count, and gap without a storage write
+ assert.deepEqual(JSON.parse(JSON.stringify(defaults)), [
+ { percent: 2, levels: 5, ladderStep: 5 },
+ { percent: 0.3, levels: 5, ladderStep: 5 },
+ ]);
+ assert.equal(f.storage.length, 0);
});
-test('new symbols default open and close ladder step to five without replacing saved values', () => {
+test("user sees that new symbols default open and close ladder step to five without replacing saved values", () => {
+ // Given the symbol mode precision and saved ladder preferences are available
const storage = createStorage();
const options = [1, 2, 3, 4, 5];
- assert.equal(loadModeSymbolPrecisionNumberOption(storage, STEP_KEYS, 'OPEN', 'ETHUSDT', '0.01', options, 5), 5);
+ // When the ladder preference contract is evaluated
+ const observed = loadModeSymbolPrecisionNumberOption(storage, STEP_KEYS, 'OPEN', 'ETHUSDT', '0.01', options, 5);
+
+ // Then sees that new symbols default open and close ladder step to five without replacing saved values
+ assert.equal(observed, 5);
assert.equal(loadModeSymbolPrecisionNumberOption(storage, STEP_KEYS, 'CLOSE', 'ETHUSDT', '0.01', options, 5), 5);
saveModeSymbolPrecisionNumberOption(storage, STEP_KEYS, 'OPEN', 'BTCUSDT', '0.01', 1, options);
@@ -131,20 +178,26 @@ test('new symbols default open and close ladder step to five without replacing s
assert.equal(loadModeSymbolPrecisionNumberOption(storage, STEP_KEYS, 'CLOSE', 'BTCUSDT', '0.01', options, 5), 3);
});
-test('ladder option persistence is scoped by the current symbol', () => {
+test("user sees that ladder option persistence is scoped by the current symbol", () => {
+ // Given the symbol mode precision and saved ladder preferences are available
const storage = createStorage();
saveModeSymbolPrecisionNumberOption(storage, MODE_KEYS, 'OPEN', 'BTCUSDT', '0.01', 3, [3, 5, 7, 9]);
+ // When the ladder preference contract is evaluated
saveModeSymbolPrecisionNumberOption(storage, MODE_KEYS, 'OPEN', 'ETHUSDT', '0.01', 7, [3, 5, 7, 9]);
+ // Then sees that ladder option persistence is scoped by the current symbol
assert.equal(loadModeSymbolPrecisionNumberOption(storage, MODE_KEYS, 'OPEN', 'BTCUSDT', '0.01', [3, 5, 7, 9], 5), 3);
assert.equal(loadModeSymbolPrecisionNumberOption(storage, MODE_KEYS, 'OPEN', 'ETHUSDT', '0.01', [3, 5, 7, 9], 5), 7);
});
-test('ladder option persistence separates open and close mode for one symbol', () => {
+test("user sees that ladder option persistence separates open and close mode for one symbol", () => {
+ // Given the symbol mode precision and saved ladder preferences are available
const storage = createStorage();
saveModeSymbolPrecisionNumberOption(storage, MODE_KEYS, 'OPEN', 'BTCUSDT', '0.01', 3, [3, 5, 7, 9]);
+ // When the ladder preference contract is evaluated
saveModeSymbolPrecisionNumberOption(storage, MODE_KEYS, 'CLOSE', 'BTCUSDT', '0.01', 9, [3, 5, 7, 9]);
+ // Then sees that ladder option persistence separates open and close mode for one symbol
assert.equal(loadModeSymbolPrecisionNumberOption(storage, MODE_KEYS, 'OPEN', 'BTCUSDT', '0.01', [3, 5, 7, 9], 5), 3);
assert.equal(loadModeSymbolPrecisionNumberOption(storage, MODE_KEYS, 'CLOSE', 'BTCUSDT', '0.01', [3, 5, 7, 9], 5), 9);
assert.deepEqual(storage.entries(), [
@@ -153,19 +206,29 @@ test('ladder option persistence separates open and close mode for one symbol', (
]);
});
-test('ladder option persistence separates orderbook precision for one symbol and mode', () => {
+test("user sees that ladder option persistence separates orderbook precision for one symbol and mode", () => {
+ // Given the symbol mode precision and saved ladder preferences are available
const storage = createStorage();
const options = [3, 5, 7, 9];
saveModeSymbolPrecisionNumberOption(storage, MODE_KEYS, 'OPEN', 'BTCUSDT', '0.01', 3, options);
+ // When the ladder preference contract is evaluated
saveModeSymbolPrecisionNumberOption(storage, MODE_KEYS, 'OPEN', 'BTCUSDT', '0.001', 9, options);
+ // Then sees that ladder option persistence separates orderbook precision for one symbol and mode
assert.equal(loadModeSymbolPrecisionNumberOption(storage, MODE_KEYS, 'OPEN', 'BTCUSDT', '0.01', options, 5), 3);
assert.equal(loadModeSymbolPrecisionNumberOption(storage, MODE_KEYS, 'OPEN', 'BTCUSDT', '0.001', options, 5), 9);
});
-test('quantity multiplier keys share the symbol-mode-precision identity', () => {
+test("user sees that quantity multiplier keys share the symbol-mode-precision identity", () => {
+ // Given the symbol mode precision and saved ladder preferences are available
+ const scenarioInputs = [MULTIPLIER_KEYS, 'OPEN', 'btcusdt', '0.01'];
+
+ // When the ladder preference contract is evaluated
+ const observed = modeSymbolPrecisionOptionStorageKey(...scenarioInputs);
+
+ // Then sees that quantity multiplier keys share the symbol-mode-precision identity
assert.equal(
- modeSymbolPrecisionOptionStorageKey(MULTIPLIER_KEYS, 'OPEN', 'btcusdt', '0.01'),
+ observed,
'jh_binance_qty_multiplier_v2:OPEN:BTCUSDT:0.01',
);
assert.equal(
@@ -174,10 +237,15 @@ test('quantity multiplier keys share the symbol-mode-precision identity', () =>
);
});
-test('ladder option persistence rejects unknown mode and skips incomplete context', () => {
+test("user sees that ladder option persistence rejects unknown mode and skips incomplete context", () => {
+ // Given the symbol mode precision and saved ladder preferences are available
const storage = createStorage();
- assert.throws(() => modeSymbolPrecisionOptionStorageKey(MODE_KEYS, 'UNKNOWN', 'BTCUSDT', '0.01'), /未知交易模式/);
+ // When the ladder preference contract is evaluated
+ const observedFailure = captureThrownError(() => modeSymbolPrecisionOptionStorageKey(MODE_KEYS, 'UNKNOWN', 'BTCUSDT', '0.01'));
+
+ // Then sees that ladder option persistence rejects unknown mode and skips incomplete context
+ assert.match(observedFailure.message, /未知交易模式/);
assert.equal(modeSymbolPrecisionOptionStorageKey(MODE_KEYS, 'OPEN', '', '0.01'), null);
assert.equal(modeSymbolPrecisionOptionStorageKey(MODE_KEYS, 'OPEN', 'BTCUSDT', ''), null);
assert.equal(loadModeSymbolPrecisionNumberOption(storage, MODE_KEYS, 'OPEN', '', '0.01', [3, 5, 7, 9], 5), null);
@@ -187,17 +255,21 @@ test('ladder option persistence rejects unknown mode and skips incomplete contex
assert.deepEqual(storage.entries(), []);
});
-test('new precision profiles do not inherit legacy symbol-only values', () => {
+test("user sees that new precision profiles do not inherit legacy symbol-only values", () => {
+ // Given the symbol mode precision and saved ladder preferences are available
const storage = createStorage();
+ // When the ladder preference contract is evaluated
storage.setItem('jh_binance_ladder_open_levels:BTCUSDT', '9');
+ // Then sees that new precision profiles do not inherit legacy symbol-only values
assert.equal(
loadModeSymbolPrecisionNumberOption(storage, MODE_KEYS, 'OPEN', 'BTCUSDT', '0.01', [3, 5, 7, 9], 5),
5,
);
});
-test('storage events accept six mode-scoped keys and reject legacy shared keys', () => {
+test("user sees that storage events accept six mode-scoped keys and reject legacy shared keys", () => {
+ // Given the symbol mode precision and saved ladder preferences are available
const keys = [
'jh_binance_ladder_open_percent',
'jh_binance_ladder_close_percent',
@@ -206,61 +278,141 @@ test('storage events accept six mode-scoped keys and reject legacy shared keys',
'jh_binance_ladder_open_step',
'jh_binance_ladder_close_step',
];
+ // When the ladder preference contract is evaluated
for (const key of keys) {
assert.equal(isModeSymbolOptionStorageKey(`${key}:BTCUSDT:0.01`, keys), true);
assert.equal(isModeSymbolOptionStorageKey(`${key}:BTCUSDT`, keys), false);
}
+ // Then sees that storage events accept six mode-scoped keys and reject legacy shared keys
assert.equal(isModeSymbolOptionStorageKey('jh_binance_ladder_levels:BTCUSDT', keys), false);
assert.equal(isModeSymbolOptionStorageKey('jh_binance_ladder_step:BTCUSDT', keys), false);
});
-test('ladder execution and UI updates use one captured mode-symbol-precision context', () => {
- assert.match(source, /const optionContext = readLadderOptionContext\(spec,\s*startSymbol,\s*startPrecision\)/);
- assert.match(source, /levels: getLadderLevels\(spec\.mode,\s*symbol,\s*precision\)/);
- assert.match(source, /ladderStep: getLadderStep\(spec\.mode,\s*symbol,\s*precision\)/);
- assert.match(source, /getLadderOpenPercent\(symbol,\s*precision\)/);
- assert.match(source, /getLadderClosePercent\(symbol,\s*precision\)/);
- assert.match(source, /let percent = optionContext\.percent/);
- assert.match(source, /const optionContext = getPanelOptionContext\(\)/);
- assert.match(source, /setLadderLevels\(value, optionContext\.mode, optionContext\.symbol, optionContext\.precision\)/);
- assert.match(source, /setLadderStep\(value, optionContext\.mode, optionContext\.symbol, optionContext\.precision\)/);
- assert.match(source, /const zhLevelText = plan\.levels === plan\.requestedLevels/);
- assert.match(source, /`\$\{plan\.percent\}% \/ \$\{zhLevelText\} \/ 幅\$\{plan\.ladderStep\}`/);
- assert.match(source, /localizedActionStatus\(plan\.spec\.statusLabel, '计划', ' plan'\)/);
+test("user keeps a captured symbol mode and precision when native page context changes", (t) => {
+ // Given saved open preferences and a captured native BTC context
+ const f = createLadderOptionHarness();
+ t.after(() => f.close());
+ f.context.setLadderOpenPercent(30, 'BTCUSDT', '0.01');
+ f.context.setLadderLevels(7, 'OPEN', 'BTCUSDT', '0.01');
+ f.context.setLadderStep(2, 'OPEN', 'BTCUSDT', '0.01');
+ const captured = f.context.getPanelOptionContext();
+
+ // When the page changes to ETH close mode before the captured options are read and updated
+ f.setNativeContext({ symbol: 'ETHUSDT', mode: 'Close', precision: '0.1' });
+ const options = f.context.readLadderOptionContext({ mode: captured.mode }, captured.symbol, captured.precision);
+ f.context.setLadderLevels(9, captured.mode, captured.symbol, captured.precision);
+ const current = f.context.getPanelOptionContext();
+ const otherOptions = f.context.readLadderOptionContext({ mode: current.mode }, current.symbol, current.precision);
+
+ // Then captured reads and writes remain scoped to BTC open mode at its original precision
+ assert.deepEqual(JSON.parse(JSON.stringify(captured)), { symbol: 'BTCUSDT', mode: 'OPEN', precision: '0.01' });
+ assert.deepEqual(JSON.parse(JSON.stringify(options)), { percent: 30, levels: 7, ladderStep: 2 });
+ assert.deepEqual(JSON.parse(JSON.stringify(current)), { symbol: 'ETHUSDT', mode: 'CLOSE', precision: '0.1' });
+ assert.deepEqual(JSON.parse(JSON.stringify(otherOptions)), { percent: 0.3, levels: 5, ladderStep: 5 });
+ assert.equal(f.storage.getItem('jh_binance_ladder_open_levels:BTCUSDT:0.01'), '9');
+ assert.equal(f.storage.getItem('jh_binance_ladder_close_levels:ETHUSDT:0.1'), null);
});
-test('open and close ladder percentage rows share the centralized ratio label', () => {
- assert.equal((source.match(/ladderOptionRow\(PANEL_COPY\.field\.ratio, PANEL_COPY\.tooltip\.ratio,/g) || []).length, 2);
+test("user sees the same ratio label with mode-specific percentages in both ladder panels", (t) => {
+ // Given both trading modes have native symbol and precision context
+ const f = createLadderOptionHarness();
+ t.after(() => f.close());
+ const closeContext = { knowsLong: true, hasLong: true, knowsShort: true, hasShort: true };
+ const rows = ['OPEN', 'CLOSE'].map(() => f.document.createElement('section'));
+
+ // When the real panel sections render their option rows
+ for (const [index, mode] of ['OPEN', 'CLOSE'].entries()) {
+ const sections = f.context.getLadderControlSections(mode, closeContext, 'BTCUSDT', '0.01');
+ rows[index].innerHTML = sections.optionRows.join('');
+ }
+
+ // Then both modes show the shared ratio label while retaining their own selectable percentages
+ assert.deepEqual(rows.map((row) => row.querySelector('span').textContent), [
+ formatLocalizedText(PANEL_COPY.field.ratio, 'en'), formatLocalizedText(PANEL_COPY.field.ratio, 'en'),
+ ]);
+ assert.deepEqual(Array.from(rows[0].querySelectorAll('[data-ladder-group="percent"]'), (button) => button.textContent), ['2%', '10%', '30%', '50%', '70%']);
+ assert.deepEqual(Array.from(rows[1].querySelectorAll('[data-ladder-group="percent"]'), (button) => button.textContent), ['0.3%', '1%', '5%', '10%', '30%']);
});
-test('ladder quantity levels and step options share one stable five-slot grid', () => {
- const optionRow = source.match(/function ladderOptionRow[\s\S]*?\n }/)?.[0] || '';
+test("user sees a stable five-column option grid in both supported panel languages", (t) => {
+ // Given five gap options and both supported interface locales
+ const f = createLadderOptionHarness();
+ t.after(() => f.close());
+ const rows = ['en', 'zh-CN'].map(() => f.document.createElement('section'));
- assert.match(optionRow, /activeUiLocale === 'en' \? '52px' : '36px'/);
- assert.match(optionRow, /repeat\(5,minmax\(0,1fr\)\)/);
- assert.doesNotMatch(optionRow, /flex-wrap/);
- assert.match(source, /data-ladder-value="\$\{value\}" style="box-sizing:border-box;width:100%;min-width:0;height:28px/);
- assert.equal((source.match(/ladderOptionRow\(PANEL_COPY\.field\.orderCount, PANEL_COPY\.tooltip\.orderCount, LADDER_LEVEL_OPTIONS/g) || []).length, 2);
- assert.equal((source.match(/ladderOptionRow\(PANEL_COPY\.field\.interval, PANEL_COPY\.tooltip\.interval, LADDER_STEP_OPTIONS/g) || []).length, 2);
- assert.doesNotMatch(source, /data-ladder-step-action|function ladderStepRow/);
-});
+ // When the real option row renderer produces each localized row
+ for (const [index, locale] of ['en', 'zh-CN'].entries()) {
+ f.context.activeUiLocale = locale;
+ rows[index].innerHTML = f.context.ladderOptionRow(PANEL_COPY.field.interval, PANEL_COPY.tooltip.interval, [1, 2, 3, 4, 5], 3, 'step');
+ }
-test('close ladder buttons match the Binance native long-short order', () => {
- const closeLongButton = "'CLOSE_LONG',\n PANEL_COPY.action.closeLong,\n 'SELL',\n closeLongDisabled,\n )";
- const closeShortButton = "'CLOSE_SHORT',\n PANEL_COPY.action.closeShort,\n 'BUY',\n closeShortDisabled,\n )";
+ // Then localized label widths preserve five fixed control columns and compact buttons
+ assert.deepEqual(rows.map((row) => row.firstElementChild.style.gridTemplateColumns), ['52px repeat(5,minmax(0,1fr))', '36px repeat(5,minmax(0,1fr))']);
+ for (const row of rows) {
+ assert.equal(row.firstElementChild.style.display, 'grid');
+ assert.equal(row.querySelectorAll('button').length, 5);
+ assert.deepEqual(Array.from(row.querySelectorAll('button'), (button) => [button.style.width, button.style.minWidth, button.style.height]), Array.from({ length: 5 }, () => ['100%', '0px', '28px']));
+ assert.equal(row.querySelector('[data-ladder-value="3"]').style.fontWeight, '500');
+ }
+});
- assert.notEqual(source.indexOf(closeLongButton), -1);
- assert.notEqual(source.indexOf(closeShortButton), -1);
- assert.ok(source.indexOf(closeLongButton) < source.indexOf(closeShortButton));
+test("user sees close-long before close-short with their native sell and buy colors", (t) => {
+ // Given confirmed long and short positions are available for closing
+ const f = createLadderOptionHarness();
+ t.after(() => f.close());
+ const closeContext = { knowsLong: true, hasLong: true, knowsShort: true, hasShort: true };
+ const panel = f.document.createElement('section');
+
+ // When the real close-mode action buttons render
+ const sections = f.context.getLadderControlSections('CLOSE', closeContext, 'BTCUSDT', '0.01');
+ panel.innerHTML = sections.actionButtons.join('');
+
+ // Then long and short actions keep the native order direction and available state
+ const buttons = Array.from(panel.querySelectorAll('button'));
+ assert.deepEqual(buttons.map((button) => button.dataset.ladderAction), ['CLOSE_LONG', 'CLOSE_SHORT']);
+ assert.deepEqual(buttons.map((button) => button.textContent), ['Close Long', 'Close Short']);
+ assert.deepEqual(buttons.map((button) => button.style.color), ['var(--color-Sell)', 'var(--color-Buy)']);
+ assert.deepEqual(buttons.map((button) => button.disabled), [false, false]);
});
-test('close side buttons match the Binance native long-short order', () => {
- const closeLongButton = `