Spaces:

lablab-ai-amd-developer-hackathon
/

Marketmind

Sleeping

Marketmind / tests /test_order_book.py

Initial MarketMind commit (Corrected Author)

10150dc 6 months ago

8.22 kB

"""
Unit tests for the CDA Order Book engine.
Tests per Phase 1 spec:
- Crossing orders execute correctly
- Non-crossing orders rest in book
- Price-time priority
- Partial fills
- Trade log accuracy
"""

import sys
import os

# Add parent to path so we can import marketmind
sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))

from engine.order_book import OrderBook, Order, Side, Trade


def test_non_crossing_orders_rest():
    """Non-crossing orders should rest in the book without matching."""
    book = OrderBook()
    book.set_tick(1)

    # Bid at 99, Ask at 101 — no cross
    bid = Order(agent_id="agent_a", side=Side.BUY, price=99.0, quantity=5, timestamp=1)
    ask = Order(agent_id="agent_b", side=Side.SELL, price=101.0, quantity=5, timestamp=1)

    trades_bid = book.submit_order(bid)
    trades_ask = book.submit_order(ask)

    assert trades_bid == [], "Non-crossing bid should not produce trades"
    assert trades_ask == [], "Non-crossing ask should not produce trades"
    assert book.best_bid == 99.0
    assert book.best_ask == 101.0
    assert book.mid_price == 100.0
    assert book.spread == 2.0
    assert len(book.bids) == 1
    assert len(book.asks) == 1
    print("✓ test_non_crossing_orders_rest")


def test_crossing_orders_execute():
    """When a buy crosses the ask, a trade should execute."""
    book = OrderBook()
    book.set_tick(1)

    # Resting ask at 100
    ask = Order(agent_id="seller", side=Side.SELL, price=100.0, quantity=5, timestamp=1)
    book.submit_order(ask)

    # Incoming buy at 100 — crosses the ask
    buy = Order(agent_id="buyer", side=Side.BUY, price=100.0, quantity=5, timestamp=2)
    trades = book.submit_order(buy)

    assert len(trades) == 1
    t = trades[0]
    assert t.price == 100.0
    assert t.quantity == 5
    assert t.buyer_id == "buyer"
    assert t.seller_id == "seller"
    assert t.aggressor_side == Side.BUY
    # Both sides fully filled — book should be empty
    assert len(book.bids) == 0
    assert len(book.asks) == 0
    print("✓ test_crossing_orders_execute")


def test_partial_fill():
    """A larger buy should partially fill against a smaller ask, with residual resting."""
    book = OrderBook()
    book.set_tick(1)

    # Resting ask: 3 units at 100
    ask = Order(agent_id="seller", side=Side.SELL, price=100.0, quantity=3, timestamp=1)
    book.submit_order(ask)

    # Incoming buy: 5 units at 100 — should fill 3, rest 2
    buy = Order(agent_id="buyer", side=Side.BUY, price=100.0, quantity=5, timestamp=2)
    trades = book.submit_order(buy)

    assert len(trades) == 1
    assert trades[0].quantity == 3
    assert len(book.asks) == 0  # ask fully consumed
    assert len(book.bids) == 1  # residual buy rests
    assert book.bids[0].quantity == 2
    assert book.bids[0].agent_id == "buyer"
    print("✓ test_partial_fill")


def test_price_priority():
    """Best price should match first (highest bid, lowest ask)."""
    book = OrderBook()
    book.set_tick(1)

    # Two bids at different prices
    bid_low = Order(agent_id="bidder_low", side=Side.BUY, price=98.0, quantity=5, timestamp=1)
    bid_high = Order(agent_id="bidder_high", side=Side.BUY, price=100.0, quantity=5, timestamp=2)
    book.submit_order(bid_low)
    book.submit_order(bid_high)

    assert book.best_bid == 100.0, f"Best bid should be 100, got {book.best_bid}"

    # Incoming sell at 99 — should match the 100 bid (better price), not the 98 bid
    sell = Order(agent_id="seller", side=Side.SELL, price=99.0, quantity=3, timestamp=3)
    trades = book.submit_order(sell)

    assert len(trades) == 1
    assert trades[0].buyer_id == "bidder_high"
    assert trades[0].price == 100.0  # fills at passive order's price
    assert trades[0].quantity == 3
    print("✓ test_price_priority")


def test_time_priority():
    """At the same price level, earlier orders should fill first (FIFO)."""
    book = OrderBook()
    book.set_tick(1)

    # Two asks at same price, different timestamps
    ask_early = Order(agent_id="early_seller", side=Side.SELL, price=100.0, quantity=5, timestamp=1)
    ask_late = Order(agent_id="late_seller", side=Side.SELL, price=100.0, quantity=5, timestamp=2)
    book.submit_order(ask_early)
    book.submit_order(ask_late)

    # Buy 3 at 100 — should match the earlier ask
    buy = Order(agent_id="buyer", side=Side.BUY, price=100.0, quantity=3, timestamp=3)
    trades = book.submit_order(buy)

    assert len(trades) == 1
    assert trades[0].seller_id == "early_seller"
    print("✓ test_time_priority")


def test_multi_level_fill():
    """A large aggressive order should sweep through multiple price levels."""
    book = OrderBook()
    book.set_tick(1)

    # Ask book: 3 @ 100, 5 @ 101, 2 @ 102
    book.submit_order(Order("s1", Side.SELL, 100.0, 3, 1))
    book.submit_order(Order("s2", Side.SELL, 101.0, 5, 2))
    book.submit_order(Order("s3", Side.SELL, 102.0, 2, 3))

    # Buy 7 @ 102 — should eat through 100 and 101 levels
    buy = Order(agent_id="buyer", side=Side.BUY, price=102.0, quantity=7, timestamp=4)
    trades = book.submit_order(buy)

    assert len(trades) == 2
    assert trades[0].price == 100.0 and trades[0].quantity == 3  # first level
    assert trades[1].price == 101.0 and trades[1].quantity == 4  # partial second level

    # s2 should have 1 unit remaining at 101
    assert len(book.asks) == 2
    assert book.asks[0].price == 101.0
    assert book.asks[0].quantity == 1
    assert book.asks[1].price == 102.0
    # No residual buy (7 filled: 3 + 4)
    assert len(book.bids) == 0
    print("✓ test_multi_level_fill")


def test_trade_log():
    """Trade log should accumulate all executed trades."""
    book = OrderBook()
    book.set_tick(1)

    book.submit_order(Order("s1", Side.SELL, 100.0, 5, 1))
    book.submit_order(Order("b1", Side.BUY, 100.0, 3, 2))

    book.set_tick(2)
    book.submit_order(Order("s2", Side.SELL, 99.0, 2, 3))
    book.submit_order(Order("b2", Side.BUY, 99.0, 2, 4))

    assert len(book.trade_log) == 2
    assert book.trade_log[0].tick == 1
    assert book.trade_log[1].tick == 2
    print("✓ test_trade_log")


def test_snapshot():
    """Snapshot should return correct book state."""
    book = OrderBook()
    book.set_tick(1)

    book.submit_order(Order("b1", Side.BUY, 99.0, 10, 1))
    book.submit_order(Order("s1", Side.SELL, 101.0, 8, 2))

    snap = book.snapshot()
    assert snap["best_bid"] == 99.0
    assert snap["best_ask"] == 101.0
    assert snap["mid_price"] == 100.0
    assert snap["spread"] == 2.0
    assert snap["bid_depth"] == 10
    assert snap["ask_depth"] == 8
    assert snap["last_trade_price"] is None  # no trades yet
    print("✓ test_snapshot")


def test_cancel_agent_orders():
    """Canceling an agent's orders should remove only their orders."""
    book = OrderBook()
    book.set_tick(1)

    book.submit_order(Order("a1", Side.BUY, 99.0, 5, 1))
    book.submit_order(Order("a2", Side.BUY, 98.0, 5, 2))
    book.submit_order(Order("a1", Side.SELL, 102.0, 5, 3))

    book.cancel_agent_orders("a1")

    assert len(book.bids) == 1
    assert book.bids[0].agent_id == "a2"
    assert len(book.asks) == 0
    print("✓ test_cancel_agent_orders")


def test_self_trade_prevention_not_required():
    """
    Note: The spec doesn't require self-trade prevention.
    Documenting that an agent CAN match against itself (this is fine in a simulation).
    """
    book = OrderBook()
    book.set_tick(1)

    book.submit_order(Order("same_agent", Side.SELL, 100.0, 5, 1))
    trades = book.submit_order(Order("same_agent", Side.BUY, 100.0, 3, 2))

    # Self-trade is allowed in this simulation
    assert len(trades) == 1
    assert trades[0].buyer_id == "same_agent"
    assert trades[0].seller_id == "same_agent"
    print("✓ test_self_trade (allowed in simulation)")


if __name__ == "__main__":
    test_non_crossing_orders_rest()
    test_crossing_orders_execute()
    test_partial_fill()
    test_price_priority()
    test_time_priority()
    test_multi_level_fill()
    test_trade_log()
    test_snapshot()
    test_cancel_agent_orders()
    test_self_trade_prevention_not_required()
    print("\n✅ All order book tests passed.")

	"""
	Unit tests for the CDA Order Book engine.

	Tests per Phase 1 spec:
	- Crossing orders execute correctly
	- Non-crossing orders rest in book
	- Price-time priority
	- Partial fills
	- Trade log accuracy
	"""

	import sys
	import os

	# Add parent to path so we can import marketmind
	sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))

	from engine.order_book import OrderBook, Order, Side, Trade


	def test_non_crossing_orders_rest():
	"""Non-crossing orders should rest in the book without matching."""
	book = OrderBook()
	book.set_tick(1)

	# Bid at 99, Ask at 101 — no cross
	bid = Order(agent_id="agent_a", side=Side.BUY, price=99.0, quantity=5, timestamp=1)
	ask = Order(agent_id="agent_b", side=Side.SELL, price=101.0, quantity=5, timestamp=1)

	trades_bid = book.submit_order(bid)
	trades_ask = book.submit_order(ask)

	assert trades_bid == [], "Non-crossing bid should not produce trades"
	assert trades_ask == [], "Non-crossing ask should not produce trades"
	assert book.best_bid == 99.0
	assert book.best_ask == 101.0
	assert book.mid_price == 100.0
	assert book.spread == 2.0
	assert len(book.bids) == 1
	assert len(book.asks) == 1
	print("✓ test_non_crossing_orders_rest")


	def test_crossing_orders_execute():
	"""When a buy crosses the ask, a trade should execute."""
	book = OrderBook()
	book.set_tick(1)

	# Resting ask at 100
	ask = Order(agent_id="seller", side=Side.SELL, price=100.0, quantity=5, timestamp=1)
	book.submit_order(ask)

	# Incoming buy at 100 — crosses the ask
	buy = Order(agent_id="buyer", side=Side.BUY, price=100.0, quantity=5, timestamp=2)
	trades = book.submit_order(buy)

	assert len(trades) == 1
	t = trades[0]
	assert t.price == 100.0
	assert t.quantity == 5
	assert t.buyer_id == "buyer"
	assert t.seller_id == "seller"
	assert t.aggressor_side == Side.BUY
	# Both sides fully filled — book should be empty
	assert len(book.bids) == 0
	assert len(book.asks) == 0
	print("✓ test_crossing_orders_execute")


	def test_partial_fill():
	"""A larger buy should partially fill against a smaller ask, with residual resting."""
	book = OrderBook()
	book.set_tick(1)

	# Resting ask: 3 units at 100
	ask = Order(agent_id="seller", side=Side.SELL, price=100.0, quantity=3, timestamp=1)
	book.submit_order(ask)

	# Incoming buy: 5 units at 100 — should fill 3, rest 2
	buy = Order(agent_id="buyer", side=Side.BUY, price=100.0, quantity=5, timestamp=2)
	trades = book.submit_order(buy)

	assert len(trades) == 1
	assert trades[0].quantity == 3
	assert len(book.asks) == 0 # ask fully consumed
	assert len(book.bids) == 1 # residual buy rests
	assert book.bids[0].quantity == 2
	assert book.bids[0].agent_id == "buyer"
	print("✓ test_partial_fill")


	def test_price_priority():
	"""Best price should match first (highest bid, lowest ask)."""
	book = OrderBook()
	book.set_tick(1)

	# Two bids at different prices
	bid_low = Order(agent_id="bidder_low", side=Side.BUY, price=98.0, quantity=5, timestamp=1)
	bid_high = Order(agent_id="bidder_high", side=Side.BUY, price=100.0, quantity=5, timestamp=2)
	book.submit_order(bid_low)
	book.submit_order(bid_high)

	assert book.best_bid == 100.0, f"Best bid should be 100, got {book.best_bid}"

	# Incoming sell at 99 — should match the 100 bid (better price), not the 98 bid
	sell = Order(agent_id="seller", side=Side.SELL, price=99.0, quantity=3, timestamp=3)
	trades = book.submit_order(sell)

	assert len(trades) == 1
	assert trades[0].buyer_id == "bidder_high"
	assert trades[0].price == 100.0 # fills at passive order's price
	assert trades[0].quantity == 3
	print("✓ test_price_priority")


	def test_time_priority():
	"""At the same price level, earlier orders should fill first (FIFO)."""
	book = OrderBook()
	book.set_tick(1)

	# Two asks at same price, different timestamps
	ask_early = Order(agent_id="early_seller", side=Side.SELL, price=100.0, quantity=5, timestamp=1)
	ask_late = Order(agent_id="late_seller", side=Side.SELL, price=100.0, quantity=5, timestamp=2)
	book.submit_order(ask_early)
	book.submit_order(ask_late)

	# Buy 3 at 100 — should match the earlier ask
	buy = Order(agent_id="buyer", side=Side.BUY, price=100.0, quantity=3, timestamp=3)
	trades = book.submit_order(buy)

	assert len(trades) == 1
	assert trades[0].seller_id == "early_seller"
	print("✓ test_time_priority")


	def test_multi_level_fill():
	"""A large aggressive order should sweep through multiple price levels."""
	book = OrderBook()
	book.set_tick(1)

	# Ask book: 3 @ 100, 5 @ 101, 2 @ 102
	book.submit_order(Order("s1", Side.SELL, 100.0, 3, 1))
	book.submit_order(Order("s2", Side.SELL, 101.0, 5, 2))
	book.submit_order(Order("s3", Side.SELL, 102.0, 2, 3))

	# Buy 7 @ 102 — should eat through 100 and 101 levels
	buy = Order(agent_id="buyer", side=Side.BUY, price=102.0, quantity=7, timestamp=4)
	trades = book.submit_order(buy)

	assert len(trades) == 2
	assert trades[0].price == 100.0 and trades[0].quantity == 3 # first level
	assert trades[1].price == 101.0 and trades[1].quantity == 4 # partial second level

	# s2 should have 1 unit remaining at 101
	assert len(book.asks) == 2
	assert book.asks[0].price == 101.0
	assert book.asks[0].quantity == 1
	assert book.asks[1].price == 102.0
	# No residual buy (7 filled: 3 + 4)
	assert len(book.bids) == 0
	print("✓ test_multi_level_fill")


	def test_trade_log():
	"""Trade log should accumulate all executed trades."""
	book = OrderBook()
	book.set_tick(1)

	book.submit_order(Order("s1", Side.SELL, 100.0, 5, 1))
	book.submit_order(Order("b1", Side.BUY, 100.0, 3, 2))

	book.set_tick(2)
	book.submit_order(Order("s2", Side.SELL, 99.0, 2, 3))
	book.submit_order(Order("b2", Side.BUY, 99.0, 2, 4))

	assert len(book.trade_log) == 2
	assert book.trade_log[0].tick == 1
	assert book.trade_log[1].tick == 2
	print("✓ test_trade_log")


	def test_snapshot():
	"""Snapshot should return correct book state."""
	book = OrderBook()
	book.set_tick(1)

	book.submit_order(Order("b1", Side.BUY, 99.0, 10, 1))
	book.submit_order(Order("s1", Side.SELL, 101.0, 8, 2))

	snap = book.snapshot()
	assert snap["best_bid"] == 99.0
	assert snap["best_ask"] == 101.0
	assert snap["mid_price"] == 100.0
	assert snap["spread"] == 2.0
	assert snap["bid_depth"] == 10
	assert snap["ask_depth"] == 8
	assert snap["last_trade_price"] is None # no trades yet
	print("✓ test_snapshot")


	def test_cancel_agent_orders():
	"""Canceling an agent's orders should remove only their orders."""
	book = OrderBook()
	book.set_tick(1)

	book.submit_order(Order("a1", Side.BUY, 99.0, 5, 1))
	book.submit_order(Order("a2", Side.BUY, 98.0, 5, 2))
	book.submit_order(Order("a1", Side.SELL, 102.0, 5, 3))

	book.cancel_agent_orders("a1")

	assert len(book.bids) == 1
	assert book.bids[0].agent_id == "a2"
	assert len(book.asks) == 0
	print("✓ test_cancel_agent_orders")


	def test_self_trade_prevention_not_required():
	"""
	Note: The spec doesn't require self-trade prevention.
	Documenting that an agent CAN match against itself (this is fine in a simulation).
	"""
	book = OrderBook()
	book.set_tick(1)

	book.submit_order(Order("same_agent", Side.SELL, 100.0, 5, 1))
	trades = book.submit_order(Order("same_agent", Side.BUY, 100.0, 3, 2))

	# Self-trade is allowed in this simulation
	assert len(trades) == 1
	assert trades[0].buyer_id == "same_agent"
	assert trades[0].seller_id == "same_agent"
	print("✓ test_self_trade (allowed in simulation)")


	if __name__ == "__main__":
	test_non_crossing_orders_rest()
	test_crossing_orders_execute()
	test_partial_fill()
	test_price_priority()
	test_time_priority()
	test_multi_level_fill()
	test_trade_log()
	test_snapshot()
	test_cancel_agent_orders()
	test_self_trade_prevention_not_required()
	print("\n✅ All order book tests passed.")