"""Test del client Bybit V5 (httpx puro) con pytest-httpx.

Tutte le chiamate HTTP vengono intercettate via `httpx_mock`. Le request
non hanno bisogno di un AsyncClient iniettato: BybitClient costruisce
internamente `httpx.AsyncClient`, e pytest-httpx applica un MockTransport
globale.
"""
from __future__ import annotations

import json

import httpx
import pytest
from cerbero_mcp.exchanges.bybit.client import (
    BASE_TESTNET,
    BybitClient,
    _f,
    _i,
)
from pytest_httpx import HTTPXMock

# ── helpers / costanti ────────────────────────────────────────


def _url(path: str) -> str:
    return BASE_TESTNET + path


def _last_request_json(httpx_mock: HTTPXMock) -> dict:
    req = httpx_mock.get_requests()[-1]
    return json.loads(req.content.decode("utf-8"))


# ── init / helpers basics ─────────────────────────────────────


def test_client_init_stores_attrs():
    c = BybitClient(api_key="k", api_secret="s", testnet=True)
    assert c.testnet is True
    assert c.base_url == BASE_TESTNET
    assert c.api_key == "k"


def test_client_init_mainnet_base_url():
    c = BybitClient(api_key="k", api_secret="s", testnet=False)
    assert c.testnet is False
    assert c.base_url == "https://api.bybit.com"


def test_client_init_custom_base_url():
    c = BybitClient(
        api_key="k", api_secret="s", testnet=True, base_url="https://example.test"
    )
    assert c.base_url == "https://example.test"


def test_client_init_injected_http_not_owned():
    http = httpx.AsyncClient()
    c = BybitClient(api_key="k", api_secret="s", http=http)
    assert c._http is http
    assert c._owns_http is False


def test_parse_helpers():
    assert _f("1.5") == 1.5
    assert _f("") is None
    assert _f(None) is None
    assert _i("42") == 42
    assert _i("") is None
    assert _i(None) is None


async def test_aclose_owned_client_closes():
    c = BybitClient(api_key="k", api_secret="s", testnet=True)
    await c.aclose()
    # An aclosed client cannot dispatch requests
    assert c._http.is_closed is True


# ── market data (public) ──────────────────────────────────────


async def test_get_ticker(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/market/tickers?category=linear&symbol=BTCUSDT"),
        json={
            "retCode": 0,
            "result": {
                "list": [
                    {
                        "symbol": "BTCUSDT",
                        "lastPrice": "60000",
                        "markPrice": "60010",
                        "bid1Price": "59995",
                        "ask1Price": "60005",
                        "volume24h": "1500.5",
                        "turnover24h": "90000000",
                        "fundingRate": "0.0001",
                        "openInterest": "50000",
                    }
                ]
            },
        },
    )
    t = await client.get_ticker("BTCUSDT", category="linear")
    assert t["symbol"] == "BTCUSDT"
    assert t["last_price"] == 60000.0
    assert t["mark_price"] == 60010.0
    assert t["bid"] == 59995.0
    assert t["ask"] == 60005.0
    assert t["volume_24h"] == 1500.5
    assert t["funding_rate"] == 0.0001
    assert t["open_interest"] == 50000.0


async def test_get_ticker_batch(client, httpx_mock: HTTPXMock):
    def _row(sym: str) -> dict:
        return {
            "symbol": sym,
            "lastPrice": "1",
            "markPrice": "1",
            "bid1Price": "1",
            "ask1Price": "1",
            "volume24h": "0",
            "turnover24h": "0",
            "fundingRate": "0",
            "openInterest": "0",
        }

    httpx_mock.add_response(
        url=_url("/v5/market/tickers?category=linear&symbol=BTCUSDT"),
        json={"retCode": 0, "result": {"list": [_row("BTCUSDT")]}},
    )
    httpx_mock.add_response(
        url=_url("/v5/market/tickers?category=linear&symbol=ETHUSDT"),
        json={"retCode": 0, "result": {"list": [_row("ETHUSDT")]}},
    )
    out = await client.get_ticker_batch(["BTCUSDT", "ETHUSDT"], category="linear")
    assert set(out.keys()) == {"BTCUSDT", "ETHUSDT"}


async def test_get_ticker_not_found(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/market/tickers?category=linear&symbol=UNKNOWNUSDT"),
        json={"retCode": 0, "result": {"list": []}},
    )
    t = await client.get_ticker("UNKNOWNUSDT", category="linear")
    assert t == {"symbol": "UNKNOWNUSDT", "error": "not_found"}


async def test_get_orderbook(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/market/orderbook?category=linear&symbol=BTCUSDT&limit=25"),
        json={
            "retCode": 0,
            "result": {
                "s": "BTCUSDT",
                "b": [["59990", "0.5"], ["59980", "1.0"]],
                "a": [["60010", "0.3"], ["60020", "0.7"]],
                "ts": 1700000000000,
            },
        },
    )
    ob = await client.get_orderbook("BTCUSDT", category="linear", limit=25)
    assert ob["symbol"] == "BTCUSDT"
    assert ob["bids"] == [[59990.0, 0.5], [59980.0, 1.0]]
    assert ob["asks"] == [[60010.0, 0.3], [60020.0, 0.7]]
    assert ob["timestamp"] == 1700000000000


async def test_get_historical(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url(
            "/v5/market/kline?category=linear&symbol=BTCUSDT&interval=60&limit=1000"
            "&start=1700000000000&end=1700003600000"
        ),
        json={
            "retCode": 0,
            "result": {
                "list": [
                    [
                        "1700000000000",
                        "60000",
                        "60500",
                        "59500",
                        "60200",
                        "100",
                        "6020000",
                    ],
                    [
                        "1700003600000",
                        "60200",
                        "60700",
                        "60000",
                        "60400",
                        "80",
                        "4832000",
                    ],
                ]
            },
        },
    )
    out = await client.get_historical(
        "BTCUSDT",
        category="linear",
        interval="60",
        start=1700000000000,
        end=1700003600000,
    )
    assert len(out["candles"]) == 2
    c0 = out["candles"][0]
    assert c0["timestamp"] == 1700000000000
    assert c0["open"] == 60000.0
    assert c0["high"] == 60500.0
    assert c0["low"] == 59500.0
    assert c0["close"] == 60200.0
    assert c0["volume"] == 100.0


async def test_get_indicators(client, httpx_mock: HTTPXMock):
    rows = [
        [
            str(1700000000000 + i * 3600_000),
            str(60000 + i * 10),
            str(60000 + i * 10 + 5),
            str(60000 + i * 10 - 5),
            str(60000 + i * 10 + 2),
            "100",
            "6000000",
        ]
        for i in range(35)
    ]
    httpx_mock.add_response(
        url=_url(
            "/v5/market/kline?category=linear&symbol=BTCUSDT&interval=60&limit=1000"
        ),
        json={"retCode": 0, "result": {"list": rows}},
    )
    out = await client.get_indicators(
        "BTCUSDT",
        category="linear",
        indicators=["rsi", "atr", "macd", "adx"],
        interval="60",
    )
    assert "rsi" in out and out["rsi"] is not None
    assert "atr" in out and out["atr"] is not None
    assert "macd" in out and out["macd"]["macd"] is not None
    assert "adx" in out and out["adx"]["adx"] is not None


async def test_get_funding_rate(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/market/tickers?category=linear&symbol=BTCUSDT"),
        json={
            "retCode": 0,
            "result": {
                "list": [
                    {
                        "symbol": "BTCUSDT",
                        "fundingRate": "0.0001",
                        "nextFundingTime": "1700003600000",
                        "lastPrice": "60000",
                        "markPrice": "60000",
                        "bid1Price": "0",
                        "ask1Price": "0",
                        "volume24h": "0",
                        "turnover24h": "0",
                        "openInterest": "0",
                    }
                ]
            },
        },
    )
    out = await client.get_funding_rate("BTCUSDT", category="linear")
    assert out["symbol"] == "BTCUSDT"
    assert out["funding_rate"] == 0.0001
    assert out["next_funding_time"] == 1700003600000


async def test_get_funding_history(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url(
            "/v5/market/funding/history?category=linear&symbol=BTCUSDT&limit=50"
        ),
        json={
            "retCode": 0,
            "result": {
                "list": [
                    {
                        "symbol": "BTCUSDT",
                        "fundingRate": "0.0001",
                        "fundingRateTimestamp": "1700000000000",
                    },
                    {
                        "symbol": "BTCUSDT",
                        "fundingRate": "0.00008",
                        "fundingRateTimestamp": "1699996400000",
                    },
                ]
            },
        },
    )
    out = await client.get_funding_history("BTCUSDT", category="linear", limit=50)
    assert len(out["history"]) == 2
    assert out["history"][0]["rate"] == 0.0001


async def test_get_open_interest(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url(
            "/v5/market/open-interest?category=linear&symbol=BTCUSDT"
            "&intervalTime=5min&limit=100"
        ),
        json={
            "retCode": 0,
            "result": {
                "list": [
                    {"openInterest": "50000", "timestamp": "1700000000000"},
                    {"openInterest": "49000", "timestamp": "1699996400000"},
                ]
            },
        },
    )
    out = await client.get_open_interest(
        "BTCUSDT", category="linear", interval="5min", limit=100
    )
    assert len(out["points"]) == 2
    assert out["current_oi"] == 50000.0


async def test_get_instruments(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/market/instruments-info?category=linear"),
        json={
            "retCode": 0,
            "result": {
                "list": [
                    {
                        "symbol": "BTCUSDT",
                        "status": "Trading",
                        "baseCoin": "BTC",
                        "quoteCoin": "USDT",
                        "priceFilter": {"tickSize": "0.1"},
                        "lotSizeFilter": {
                            "qtyStep": "0.001",
                            "minOrderQty": "0.001",
                        },
                    }
                ]
            },
        },
    )
    out = await client.get_instruments(category="linear")
    assert len(out["instruments"]) == 1
    inst = out["instruments"][0]
    assert inst["symbol"] == "BTCUSDT"
    assert inst["tick_size"] == 0.1
    assert inst["qty_step"] == 0.001


async def test_get_option_chain(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/market/instruments-info?category=option&baseCoin=BTC"),
        json={
            "retCode": 0,
            "result": {
                "list": [
                    {
                        "symbol": "BTC-30JUN25-50000-C",
                        "baseCoin": "BTC",
                        "settleCoin": "USDC",
                        "optionsType": "Call",
                        "launchTime": "1700000000000",
                        "deliveryTime": "1719734400000",
                    },
                    {
                        "symbol": "BTC-30JUN25-50000-P",
                        "baseCoin": "BTC",
                        "settleCoin": "USDC",
                        "optionsType": "Put",
                        "launchTime": "1700000000000",
                        "deliveryTime": "1719734400000",
                    },
                ]
            },
        },
    )
    out = await client.get_option_chain(base_coin="BTC")
    assert len(out["options"]) == 2
    assert out["options"][0]["type"] == "Call"


# ── account / positions / orders (signed reads) ───────────────


async def test_get_positions(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/position/list?category=linear&settleCoin=USDT"),
        json={
            "retCode": 0,
            "result": {
                "list": [
                    {
                        "symbol": "BTCUSDT",
                        "side": "Buy",
                        "size": "0.1",
                        "avgPrice": "60000",
                        "unrealisedPnl": "50",
                        "leverage": "10",
                        "liqPrice": "50000",
                        "positionValue": "6000",
                    }
                ]
            },
        },
    )
    out = await client.get_positions(category="linear")
    assert len(out) == 1
    p = out[0]
    assert p["symbol"] == "BTCUSDT"
    assert p["side"] == "Buy"
    assert p["size"] == 0.1
    assert p["entry_price"] == 60000.0
    assert p["liquidation_price"] == 50000.0
    # signed: header X-BAPI-API-KEY presente
    req = httpx_mock.get_requests()[-1]
    assert req.headers.get("X-BAPI-API-KEY") == "test_key"
    assert "X-BAPI-SIGN" in req.headers


async def test_get_account_summary(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/account/wallet-balance?accountType=UNIFIED"),
        json={
            "retCode": 0,
            "result": {
                "list": [
                    {
                        "accountType": "UNIFIED",
                        "totalEquity": "10000",
                        "totalWalletBalance": "9500",
                        "totalMarginBalance": "9800",
                        "totalAvailableBalance": "9000",
                        "totalPerpUPL": "200",
                        "coin": [
                            {
                                "coin": "USDT",
                                "walletBalance": "9500",
                                "equity": "9700",
                            }
                        ],
                    }
                ]
            },
        },
    )
    out = await client.get_account_summary()
    assert out["equity"] == 10000.0
    assert out["available_balance"] == 9000.0
    assert out["unrealized_pnl"] == 200.0
    assert len(out["coins"]) == 1
    assert out["coins"][0]["coin"] == "USDT"


async def test_get_trade_history(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/execution/list?category=linear&limit=50"),
        json={
            "retCode": 0,
            "result": {
                "list": [
                    {
                        "symbol": "BTCUSDT",
                        "side": "Buy",
                        "execQty": "0.01",
                        "execPrice": "60000",
                        "execFee": "0.1",
                        "execTime": "1700000000000",
                        "orderId": "abc",
                    }
                ]
            },
        },
    )
    out = await client.get_trade_history(category="linear", limit=50)
    assert len(out) == 1
    assert out[0]["symbol"] == "BTCUSDT"
    assert out[0]["size"] == 0.01
    assert out[0]["price"] == 60000.0


async def test_get_open_orders(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/order/realtime?category=linear&settleCoin=USDT"),
        json={
            "retCode": 0,
            "result": {
                "list": [
                    {
                        "symbol": "BTCUSDT",
                        "orderId": "o1",
                        "side": "Buy",
                        "qty": "0.1",
                        "price": "59000",
                        "orderType": "Limit",
                        "orderStatus": "New",
                        "reduceOnly": False,
                    }
                ]
            },
        },
    )
    out = await client.get_open_orders(category="linear")
    assert len(out) == 1
    assert out[0]["order_id"] == "o1"
    assert out[0]["price"] == 59000.0


# ── basis / spreads ────────────────────────────────────────────


async def test_get_basis_spot_perp(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/market/tickers?category=spot&symbol=BTCUSDT"),
        json={
            "retCode": 0,
            "result": {
                "list": [
                    {
                        "symbol": "BTCUSDT",
                        "lastPrice": "60000",
                        "markPrice": "60000",
                        "bid1Price": "59995",
                        "ask1Price": "60005",
                        "volume24h": "0",
                        "turnover24h": "0",
                        "fundingRate": "0",
                        "openInterest": "0",
                    }
                ]
            },
        },
    )
    httpx_mock.add_response(
        url=_url("/v5/market/tickers?category=linear&symbol=BTCUSDT"),
        json={
            "retCode": 0,
            "result": {
                "list": [
                    {
                        "symbol": "BTCUSDT",
                        "lastPrice": "60120",
                        "markPrice": "60120",
                        "bid1Price": "60115",
                        "ask1Price": "60125",
                        "volume24h": "0",
                        "turnover24h": "0",
                        "fundingRate": "0.0001",
                        "openInterest": "0",
                    }
                ]
            },
        },
    )
    out = await client.get_basis_spot_perp("BTC")
    assert out["asset"] == "BTC"
    assert out["spot_price"] == 60000.0
    assert out["perp_price"] == 60120.0
    assert out["basis_abs"] == 120.0
    assert round(out["basis_pct"], 3) == 0.2


# ── trading writes ────────────────────────────────────────────


async def test_place_order_limit(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/order/create"),
        method="POST",
        json={
            "retCode": 0,
            "result": {"orderId": "ord123", "orderLinkId": ""},
        },
    )
    out = await client.place_order(
        category="linear",
        symbol="BTCUSDT",
        side="Buy",
        qty=0.01,
        order_type="Limit",
        price=60000.0,
        tif="GTC",
    )
    assert out["order_id"] == "ord123"
    body = _last_request_json(httpx_mock)
    assert body["category"] == "linear"
    assert body["symbol"] == "BTCUSDT"
    assert body["side"] == "Buy"
    assert body["qty"] == "0.01"
    assert body["orderType"] == "Limit"
    assert body["price"] == "60000.0"
    assert body["timeInForce"] == "GTC"


async def test_place_order_error(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/order/create"),
        method="POST",
        json={"retCode": 10001, "retMsg": "insufficient balance"},
    )
    out = await client.place_order(
        category="linear",
        symbol="BTCUSDT",
        side="Buy",
        qty=0.01,
        order_type="Market",
    )
    assert out.get("error") == "insufficient balance"
    assert out.get("code") == 10001


async def test_amend_order(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/order/amend"),
        method="POST",
        json={"retCode": 0, "result": {"orderId": "ord1"}},
    )
    out = await client.amend_order(
        category="linear", symbol="BTCUSDT", order_id="ord1", new_qty=0.02
    )
    assert out["order_id"] == "ord1"
    body = _last_request_json(httpx_mock)
    assert body["orderId"] == "ord1"
    assert body["qty"] == "0.02"
    assert "price" not in body


async def test_place_order_option_adds_link_id(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/order/create"),
        method="POST",
        json={
            "retCode": 0,
            "result": {"orderId": "opt1", "orderLinkId": "cerbero-abc"},
        },
    )
    await client.place_order(
        category="option",
        symbol="BTC-24APR26-96000-C-USDT",
        side="Buy",
        qty=0.01,
        order_type="Limit",
        price=5.0,
    )
    body = _last_request_json(httpx_mock)
    assert "orderLinkId" in body
    assert body["orderLinkId"].startswith("cerbero-")


async def test_place_order_linear_no_link_id(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/order/create"),
        method="POST",
        json={"retCode": 0, "result": {"orderId": "x"}},
    )
    await client.place_order(
        category="linear",
        symbol="BTCUSDT",
        side="Buy",
        qty=0.01,
        order_type="Market",
    )
    body = _last_request_json(httpx_mock)
    assert "orderLinkId" not in body


async def test_place_combo_order_batch_option(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/order/create-batch"),
        method="POST",
        json={
            "retCode": 0,
            "result": {
                "list": [
                    {"orderId": "ord-1", "orderLinkId": "cerbero-leg1"},
                    {"orderId": "ord-2", "orderLinkId": "cerbero-leg2"},
                ]
            },
        },
    )
    legs = [
        {
            "symbol": "BTC-30APR26-75000-C-USDT",
            "side": "Buy",
            "qty": 0.01,
            "order_type": "Limit",
            "price": 5.0,
        },
        {
            "symbol": "BTC-30APR26-80000-C-USDT",
            "side": "Sell",
            "qty": 0.01,
            "order_type": "Limit",
            "price": 3.0,
        },
    ]
    out = await client.place_combo_order(category="option", legs=legs)
    assert len(out["orders"]) == 2
    assert out["orders"][0]["order_id"] == "ord-1"
    body = _last_request_json(httpx_mock)
    assert body["category"] == "option"
    request = body["request"]
    assert len(request) == 2
    assert request[0]["symbol"] == "BTC-30APR26-75000-C-USDT"
    assert request[0]["qty"] == "0.01"
    assert request[0]["orderType"] == "Limit"
    assert "orderLinkId" in request[0]


async def test_place_combo_order_error(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/order/create-batch"),
        method="POST",
        json={"retCode": 10001, "retMsg": "invalid leg"},
    )
    out = await client.place_combo_order(
        category="option",
        legs=[
            {
                "symbol": "X",
                "side": "Buy",
                "qty": 1,
                "order_type": "Limit",
                "price": 1.0,
            },
            {
                "symbol": "Y",
                "side": "Sell",
                "qty": 1,
                "order_type": "Limit",
                "price": 1.0,
            },
        ],
    )
    assert out["error"] == "invalid leg"
    assert out["code"] == 10001


async def test_place_combo_order_rejects_non_option(client):
    with pytest.raises(ValueError, match="option"):
        await client.place_combo_order(
            category="linear",
            legs=[
                {
                    "symbol": "BTCUSDT",
                    "side": "Buy",
                    "qty": 0.01,
                    "order_type": "Market",
                },
                {
                    "symbol": "ETHUSDT",
                    "side": "Sell",
                    "qty": 0.01,
                    "order_type": "Market",
                },
            ],
        )


async def test_cancel_order(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/order/cancel"),
        method="POST",
        json={"retCode": 0, "result": {"orderId": "ord1"}},
    )
    out = await client.cancel_order(category="linear", symbol="BTCUSDT", order_id="ord1")
    assert out["order_id"] == "ord1"
    assert out["status"] == "cancelled"
    body = _last_request_json(httpx_mock)
    assert body["category"] == "linear"
    assert body["symbol"] == "BTCUSDT"
    assert body["orderId"] == "ord1"


async def test_cancel_all_orders(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/order/cancel-all"),
        method="POST",
        json={
            "retCode": 0,
            "result": {"list": [{"orderId": "o1"}, {"orderId": "o2"}]},
        },
    )
    out = await client.cancel_all_orders(category="linear", symbol="BTCUSDT")
    assert out["cancelled_ids"] == ["o1", "o2"]
    body = _last_request_json(httpx_mock)
    assert body["category"] == "linear"
    assert body["symbol"] == "BTCUSDT"


async def test_set_stop_loss(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/position/trading-stop"),
        method="POST",
        json={"retCode": 0, "result": {}},
    )
    out = await client.set_stop_loss(
        category="linear", symbol="BTCUSDT", stop_loss=55000.0
    )
    body = _last_request_json(httpx_mock)
    assert body["category"] == "linear"
    assert body["symbol"] == "BTCUSDT"
    assert body["stopLoss"] == "55000.0"
    assert body.get("positionIdx", 0) == 0
    assert out["status"] == "stop_loss_set"


async def test_set_take_profit(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/position/trading-stop"),
        method="POST",
        json={"retCode": 0, "result": {}},
    )
    out = await client.set_take_profit(
        category="linear", symbol="BTCUSDT", take_profit=65000.0
    )
    body = _last_request_json(httpx_mock)
    assert body["takeProfit"] == "65000.0"
    assert out["status"] == "take_profit_set"


async def test_close_position(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/position/list?category=linear&settleCoin=USDT"),
        json={
            "retCode": 0,
            "result": {
                "list": [
                    {
                        "symbol": "BTCUSDT",
                        "side": "Buy",
                        "size": "0.1",
                        "avgPrice": "60000",
                        "unrealisedPnl": "0",
                        "leverage": "10",
                        "liqPrice": "0",
                        "positionValue": "6000",
                    }
                ]
            },
        },
    )
    httpx_mock.add_response(
        url=_url("/v5/order/create"),
        method="POST",
        json={
            "retCode": 0,
            "result": {"orderId": "closeord", "orderLinkId": ""},
        },
    )
    out = await client.close_position(category="linear", symbol="BTCUSDT")
    assert out["status"] == "submitted"
    # the LAST request is the place_order body
    body = _last_request_json(httpx_mock)
    assert body["side"] == "Sell"
    assert body["qty"] == "0.1"
    assert body["reduceOnly"] is True
    assert body["orderType"] == "Market"


async def test_set_leverage(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/position/set-leverage"),
        method="POST",
        json={"retCode": 0, "result": {}},
    )
    out = await client.set_leverage(category="linear", symbol="BTCUSDT", leverage=5)
    body = _last_request_json(httpx_mock)
    assert body["category"] == "linear"
    assert body["symbol"] == "BTCUSDT"
    assert body["buyLeverage"] == "5"
    assert body["sellLeverage"] == "5"
    assert out["status"] == "leverage_set"


async def test_switch_position_mode(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/position/switch-mode"),
        method="POST",
        json={"retCode": 0, "result": {}},
    )
    out = await client.switch_position_mode(
        category="linear", symbol="BTCUSDT", mode="hedge"
    )
    body = _last_request_json(httpx_mock)
    assert body["mode"] == 3
    assert out["status"] == "mode_switched"


async def test_transfer_asset(client, httpx_mock: HTTPXMock):
    httpx_mock.add_response(
        url=_url("/v5/asset/transfer/inter-transfer"),
        method="POST",
        json={"retCode": 0, "result": {"transferId": "tx123"}},
    )
    out = await client.transfer_asset(
        coin="USDT", amount=100.0, from_type="UNIFIED", to_type="FUND"
    )
    body = _last_request_json(httpx_mock)
    assert body["coin"] == "USDT"
    assert body["amount"] == "100.0"
    assert body["fromAccountType"] == "UNIFIED"
    assert body["toAccountType"] == "FUND"
    assert out["transfer_id"] == "tx123"