* refactor(binance): introduce BinanceConfig for endpoint + timing knobs
Replaces the file-private READ_TIMEOUT / MAX_RECONNECT_ATTEMPTS / size
limit constants with a Default-equipped BinanceConfig the caller can hand
to a new connect_with_config(). connect() forwards to it with the
defaults, so the public API stays backwards-compatible.
Behaviour-preserving: every default matches the value of the constant it
replaces, and the WebSocketConfig is built the same way. The change
unlocks two real use-cases — pointing at Binance Testnet
(wss://testnet.binance.vision) and pointing at a local mock server with
millisecond-scale reconnect timing in tests.
* test(binance): cover the Interval table and the empty-symbol guard
Three quick wins that don't need a live or mock socket:
- interval_as_str_covers_every_variant pins every wire-format mapping in
one table so a typo on any of the 14 variants is caught.
- binance_config_default_matches_production_endpoint guards the default
base URL and timing knobs against an accidental drift.
- connect_rejects_an_empty_symbol_list exercises the guard before the
WebSocket handshake — the one async path we can hit without a server.
* test(binance): cover the async / reconnect / control-frame paths
Adds a small mock-WebSocket scaffold built on a `127.0.0.1:0` listener
and tokio-tungstenite's `accept_async`, plus nine integration tests that
drive `BinanceKlineStream::next_event` through every branch:
- text + binary kline frames decode to a KlineEvent
- inbound Ping is answered with a Pong, then the kline arrives
- inbound Pong / Frame variants are silently skipped
- a server-side Close triggers a transparent reconnect that then
serves the kline
- a stalled connection trips read_timeout and reconnects on its own
- close() flips the closed flag and next_event() yields None forever
- when every reconnect attempt is refused, next_event surfaces an Err
- a "kline" envelope whose numbers are unparseable bubbles up as
Error::Malformed rather than being silently skipped
`one_shot_server` drops the listener as soon as the first accept is
done, so a follow-up reconnect lands on a refused port — that is what
lets the exhaustion test hit the final `last_err.expect(...)`.
The whole suite runs in ~4 s with millisecond-scale reconnect timings
supplied via the new test-only [`test_config`].
* test(binance): drop defensive cold-paths in the mock-WS scaffolding
Codecov's patch report on PR #34 flagged seven uncovered lines, all of
them in the test scaffolding rather than in production code:
- the `let Ok((stream, _)) = … else { return }` shortcut and the
`if let Ok(ws) = accept_async(stream).await { … }` branch in the
mock-server helpers — both error arms never fire on a passing test
- the closing braces of the spawned-task bodies in the close-frame and
read-timeout reconnect tests — the spawned async blocks were getting
killed mid-drain when the test asserted and returned
Refactor the helpers to `.unwrap()` every Result (a failure here is a
bug in the scaffold, not in production) and have `multi_shot_server`
accept a fixed `n_accepts`, await every spawned inner task, and hand
the outer JoinHandle back to the caller.
Refactor the two affected tests to capture that JoinHandle, collapse
the per-index `if/else` so both arms reach the same trailing
expression, swap the read-timeout drain for a bounded sleep, and
await `server_done` at the end. Every handler now reaches its closing
brace before the runtime is torn down, so coverage on the patch should
collapse from 97.89 % to 100 %.
* test(binance): cover the non-kline-skip path and simplify the Ping arm
After the scaffolding fix landed three lines on binance.rs were still
uncovered:
- L305 / L313: the Text- and Binary-arm "frame was not a kline, keep
reading" fall-throughs. No existing test drove the loop through a
non-kline frame followed by a kline; the new
`next_event_skips_non_kline_frames_and_returns_the_next_kline` does
exactly that (Text ack, Binary id frame, then a real kline).
- L317: the Ping-Err defensive arm that forced a reconnect when the
Pong reply itself failed to write. A failed Pong reply means the
socket is already dead, so the very next read will surface the error
and reconnect through the existing timeout/err branch — one tokio
scheduling iteration later. Drop the defensive arm and write the
Pong reply best-effort. Same observable behaviour, no test back
door, no dead-line guard.
Repo coverage on `cov/binance-mock-ws` now sits at 100 %.
kingchenc
9acb2f607e