bbstrader 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

tests/engine/test_events.py

@@ -0,0 +1,300 @@
+import io
+import unittest
+from contextlib import redirect_stdout
+from datetime import datetime
+
+from bbstrader.btengine.event import (
+    Event,
+    Events,
+    FillEvent,
+    MarketEvent,
+    OrderEvent,
+    SignalEvent,
+)
+
+
+class TestEventsEnum(unittest.TestCase):
+    """Tests the Events Enum."""
+
+    def test_enum_values(self):
+        self.assertEqual(Events.MARKET.value, "MARKET")
+        self.assertEqual(Events.SIGNAL.value, "SIGNAL")
+        self.assertEqual(Events.ORDER.value, "ORDER")
+        self.assertEqual(Events.FILL.value, "FILL")
+
+
+class TestMarketEvent(unittest.TestCase):
+    """Tests the MarketEvent class."""
+
+    def test_market_event_creation(self):
+        """Test MarketEvent initialization and type."""
+        event = MarketEvent()
+        self.assertIsInstance(event, Event)
+        self.assertEqual(event.type, Events.MARKET)
+
+
+class TestSignalEvent(unittest.TestCase):
+    """Tests the SignalEvent class."""
+
+    def setUp(self):
+        """Set up common data for tests."""
+        self.timestamp = datetime(2023, 10, 27, 10, 30, 0)
+        self.strategy_id = 1
+        self.symbol = "AAPL"
+        self.signal_type_long = "LONG"
+        self.signal_type_short = "SHORT"
+        self.signal_type_exit = "EXIT"
+        self.quantity = 150
+        self.strength = 1.5
+        self.price = 170.50
+        self.stoplimit = 168.00
+
+    def test_signal_event_creation_long(self):
+        """Test SignalEvent initialization with all parameters for LONG."""
+        event = SignalEvent(
+            strategy_id=self.strategy_id,
+            symbol=self.symbol,
+            datetime=self.timestamp,
+            signal_type=self.signal_type_long,
+            quantity=self.quantity,
+            strength=self.strength,
+            price=self.price,
+            stoplimit=self.stoplimit,
+        )
+        self.assertIsInstance(event, Event)
+        self.assertEqual(event.type, Events.SIGNAL)
+        self.assertEqual(event.strategy_id, self.strategy_id)
+        self.assertEqual(event.symbol, self.symbol)
+        self.assertEqual(event.datetime, self.timestamp)
+        self.assertEqual(event.signal_type, self.signal_type_long)
+        self.assertEqual(event.quantity, self.quantity)
+        self.assertEqual(event.strength, self.strength)
+        self.assertEqual(event.price, self.price)
+        self.assertEqual(event.stoplimit, self.stoplimit)
+
+    def test_signal_event_creation_short_defaults(self):
+        """Test SignalEvent initialization with defaults for SHORT."""
+        event = SignalEvent(
+            strategy_id=self.strategy_id,
+            symbol=self.symbol,
+            datetime=self.timestamp,
+            signal_type=self.signal_type_short,
+        )
+        self.assertIsInstance(event, Event)
+        self.assertEqual(event.type, Events.SIGNAL)
+        self.assertEqual(event.strategy_id, self.strategy_id)
+        self.assertEqual(event.symbol, self.symbol)
+        self.assertEqual(event.datetime, self.timestamp)
+        self.assertEqual(event.signal_type, self.signal_type_short)
+        # Check defaults
+        self.assertEqual(event.quantity, 100)  # Default quantity
+        self.assertEqual(event.strength, 1.0)  # Default strength
+        self.assertIsNone(event.price)  # Default price
+        self.assertIsNone(event.stoplimit)  # Default stoplimit
+
+    def test_signal_event_creation_exit(self):
+        """Test SignalEvent initialization for EXIT."""
+        event = SignalEvent(
+            strategy_id=self.strategy_id,
+            symbol=self.symbol,
+            datetime=self.timestamp,
+            signal_type=self.signal_type_exit,
+            quantity=50,  # Different quantity for exit
+        )
+        self.assertIsInstance(event, Event)
+        self.assertEqual(event.type, Events.SIGNAL)
+        self.assertEqual(event.signal_type, self.signal_type_exit)
+        self.assertEqual(event.quantity, 50)
+
+
+class TestOrderEvent(unittest.TestCase):
+    """Tests the OrderEvent class."""
+
+    def setUp(self):
+        """Set up common data for tests."""
+        self.symbol = "GOOG"
+        self.quantity = 75
+        self.price_lmt = 135.00
+        self.signal_ref = "Signal_123"
+
+    def test_order_event_creation_mkt_buy(self):
+        """Test MKT BUY OrderEvent initialization."""
+        event = OrderEvent(
+            symbol=self.symbol,
+            order_type="MKT",
+            quantity=self.quantity,
+            direction="BUY",
+            signal=self.signal_ref,
+        )
+        self.assertIsInstance(event, Event)
+        self.assertEqual(event.type, Events.ORDER)
+        self.assertEqual(event.symbol, self.symbol)
+        self.assertEqual(event.order_type, "MKT")
+        self.assertEqual(event.quantity, self.quantity)
+        self.assertEqual(event.direction, "BUY")
+        self.assertIsNone(event.price)  # Price is None for MKT
+        self.assertEqual(event.signal, self.signal_ref)
+
+    def test_order_event_creation_lmt_sell(self):
+        """Test LMT SELL OrderEvent initialization."""
+        event = OrderEvent(
+            symbol=self.symbol,
+            order_type="LMT",
+            quantity=self.quantity,
+            direction="SELL",
+            price=self.price_lmt,
+            signal=self.signal_ref,
+        )
+        self.assertIsInstance(event, Event)
+        self.assertEqual(event.type, Events.ORDER)
+        self.assertEqual(event.symbol, self.symbol)
+        self.assertEqual(event.order_type, "LMT")
+        self.assertEqual(event.quantity, self.quantity)
+        self.assertEqual(event.direction, "SELL")
+        self.assertEqual(event.price, self.price_lmt)
+        self.assertEqual(event.signal, self.signal_ref)
+
+    def test_print_order(self):
+        """Test the print_order method output."""
+        event = OrderEvent(
+            symbol=self.symbol,
+            order_type="LMT",
+            quantity=self.quantity,
+            direction="SELL",
+            price=self.price_lmt,
+        )
+        # Redirect stdout to capture print output
+        captured_output = io.StringIO()
+        try:
+            with redirect_stdout(captured_output):
+                event.print_order()  # Call the *instance* method
+            output = captured_output.getvalue().strip()
+            expected_output = f"Order: Symbol={self.symbol}, Type=LMT, Quantity={self.quantity}, Direction=SELL, Price={self.price_lmt}"
+            self.assertEqual(output, expected_output)
+        except AttributeError:
+            self.fail(
+                "print_order is likely defined inside __init__ and not as a class method."
+            )
+
+
+class TestFillEvent(unittest.TestCase):
+    """Tests the FillEvent class."""
+
+    def setUp(self):
+        """Set up common data for tests."""
+        self.timestamp = datetime(2023, 10, 27, 10, 35, 15)
+        self.symbol = "MSFT"
+        self.exchange = "NYSE"
+        self.fill_cost = 330.25
+        self.order_ref = "Order_456"
+
+    def create_fill_event(self, quantity, commission=None, direction="BUY"):
+        """Helper method to create a FillEvent."""
+        return FillEvent(
+            timeindex=self.timestamp,
+            symbol=self.symbol,
+            exchange=self.exchange,
+            quantity=quantity,
+            direction=direction,
+            fill_cost=self.fill_cost
+            * quantity,  # Example fill cost based on price * quantity
+            commission=commission,
+            order=self.order_ref,
+        )
+
+    def test_fill_event_creation_buy_calculated_commission_small(self):
+        """Test FillEvent BUY with calculated commission (qty <= 500)."""
+        quantity = 100
+        event = self.create_fill_event(quantity=quantity)
+
+        self.assertIsInstance(event, Event)
+        self.assertEqual(event.type, Events.FILL)
+        self.assertEqual(event.timeindex, self.timestamp)
+        self.assertEqual(event.symbol, self.symbol)
+        self.assertEqual(event.exchange, self.exchange)
+        self.assertEqual(event.quantity, quantity)
+        self.assertEqual(event.direction, "BUY")
+        self.assertEqual(event.fill_cost, self.fill_cost * quantity)
+        self.assertEqual(event.order, self.order_ref)
+
+        # Test commission calculation (<= 500)
+        expected_commission = max(1.3, 0.013 * quantity)
+        self.assertAlmostEqual(
+            event.commission, expected_commission
+        )  # Use assertAlmostEqual for floats
+        self.assertAlmostEqual(event.commission, 1.30)  # 0.013 * 100 = 1.3
+
+    def test_fill_event_creation_sell_calculated_commission_large(self):
+        """Test FillEvent SELL with calculated commission (qty > 500)."""
+        quantity = 600
+        event = self.create_fill_event(quantity=quantity, direction="SELL")
+
+        self.assertIsInstance(event, Event)
+        self.assertEqual(event.type, Events.FILL)
+        self.assertEqual(event.direction, "SELL")
+        self.assertEqual(event.quantity, quantity)
+
+        # Test commission calculation (> 500)
+        expected_commission = max(1.3, 0.008 * quantity)
+        self.assertAlmostEqual(event.commission, expected_commission)
+        self.assertAlmostEqual(event.commission, 4.8)  # 0.008 * 600 = 4.8
+
+    def test_fill_event_creation_calculated_commission_edge_500(self):
+        """Test FillEvent with calculated commission (qty == 500)."""
+        quantity = 500
+        event = self.create_fill_event(quantity=quantity)
+
+        # Test commission calculation (<= 500 rule applies)
+        expected_commission = max(1.3, 0.013 * quantity)
+        self.assertAlmostEqual(event.commission, expected_commission)
+        self.assertAlmostEqual(event.commission, 6.5)  # 0.013 * 500 = 6.5
+
+    def test_fill_event_creation_calculated_commission_minimum(self):
+        """Test FillEvent with calculated commission hitting minimum."""
+        quantity = 50
+        event = self.create_fill_event(quantity=quantity)
+
+        # Test commission calculation (minimum rule applies)
+        expected_commission = max(1.3, 0.013 * quantity)  # 0.013 * 50 = 0.65
+        self.assertAlmostEqual(event.commission, expected_commission)
+        self.assertAlmostEqual(event.commission, 1.3)  # max(1.3, 0.65) = 1.3
+
+    def test_fill_event_creation_provided_commission(self):
+        """Test FillEvent with explicitly provided commission."""
+        quantity = 200
+        provided_commission = 5.0
+        event = self.create_fill_event(
+            quantity=quantity, commission=provided_commission
+        )
+
+        self.assertIsInstance(event, Event)
+        self.assertEqual(event.type, Events.FILL)
+        self.assertEqual(event.quantity, quantity)
+
+        # Test that provided commission overrides calculation
+        self.assertEqual(event.commission, provided_commission)
+
+    def test_calculate_ib_commission_method(self):
+        """Directly test the commission calculation method."""
+        # Create a dummy event just to call the method (attributes don't matter here)
+        event_small = FillEvent(datetime.now(), "SYM", "EXCH", 100, "BUY", 1000)
+        event_large = FillEvent(datetime.now(), "SYM", "EXCH", 600, "BUY", 6000)
+        event_edge = FillEvent(datetime.now(), "SYM", "EXCH", 500, "BUY", 5000)
+        event_min = FillEvent(datetime.now(), "SYM", "EXCH", 10, "BUY", 100)
+
+        self.assertAlmostEqual(
+            event_small.calculate_ib_commission(), 1.3
+        )  # max(1.3, 0.013*100=1.3)
+        self.assertAlmostEqual(
+            event_large.calculate_ib_commission(), 4.8
+        )  # max(1.3, 0.008*600=4.8)
+        self.assertAlmostEqual(
+            event_edge.calculate_ib_commission(), 6.5
+        )  # max(1.3, 0.013*500=6.5)
+        self.assertAlmostEqual(
+            event_min.calculate_ib_commission(), 1.3
+        )  # max(1.3, 0.013*10=0.13)
+
+
+if __name__ == "__main__":
+    unittest.main(argv=[""], exit=False)

tests/engine/test_execution.py

@@ -0,0 +1,219 @@
+import unittest
+from collections import namedtuple
+from datetime import datetime
+from queue import Queue
+from unittest.mock import Mock, patch
+
+from bbstrader.btengine.data import DataHandler
+from bbstrader.btengine.event import FillEvent, OrderEvent
+from bbstrader.btengine.execution import MT5ExecutionHandler, SimExecutionHandler
+from bbstrader.metatrader.utils import SymbolType
+
+
+class TestSimExecutionHandler(unittest.TestCase):
+    """
+    Tests for the SimExecutionHandler class.
+    """
+
+    def setUp(self):
+        """Set up test fixtures before each test."""
+        self.events_queue = Queue()
+        self.mock_data_handler = Mock(spec=DataHandler)
+        self.mock_logger = Mock()
+
+        self.test_time = datetime(2023, 1, 1, 12, 0, 0)
+        self.mock_data_handler.get_latest_bar_datetime.return_value = self.test_time
+
+        self.handler = SimExecutionHandler(
+            events=self.events_queue,
+            data=self.mock_data_handler,
+            logger=self.mock_logger,
+            commission=5.0,
+            exchange="SIMEX",
+        )
+
+    def test_execute_order_creates_and_queues_fill_event(self):
+        """
+        Tests that SimExecutionHandler correctly creates a FillEvent
+        from an OrderEvent and puts it onto the events queue.
+        """
+        order_event = OrderEvent(
+            symbol="AAPL",
+            order_type="MKT",
+            quantity=100,
+            direction="BUY",
+            price=150.0,
+            signal="LONG",
+        )
+
+        self.handler.execute_order(order_event)
+
+        self.mock_data_handler.get_latest_bar_datetime.assert_called_once_with("AAPL")
+
+        self.assertEqual(self.events_queue.qsize(), 1)
+        fill_event = self.events_queue.get()
+
+        self.assertIsInstance(fill_event, FillEvent)
+        self.assertEqual(fill_event.timeindex, self.test_time)
+        self.assertEqual(fill_event.symbol, "AAPL")
+        self.assertEqual(fill_event.exchange, "SIMEX")
+        self.assertEqual(fill_event.quantity, 100)
+        self.assertEqual(fill_event.direction, "BUY")
+        self.assertIsNone(fill_event.fill_cost)
+        self.assertEqual(fill_event.commission, 5.0)
+        self.assertEqual(fill_event.order, "LONG")
+
+        expected_log_msg = (
+            "BUY ORDER FILLED: SYMBOL=AAPL, QUANTITY=100, PRICE @150.0 EXCHANGE=SIMEX"
+        )
+        self.mock_logger.info.assert_called_once_with(
+            expected_log_msg, custom_time=self.test_time
+        )
+
+
+SymbolInfo = namedtuple(
+    "SymbolInfo", ["trade_contract_size", "volume_min", "volume_max"]
+)
+
+
+class TestMT5ExecutionHandler(unittest.TestCase):
+    """
+    Tests for the MT5ExecutionHandler class.
+    The 'Account' class dependency is mocked to avoid any real API calls.
+    """
+
+    def setUp(self):
+        """Set up test fixtures before each test."""
+        self.events_queue = Queue()
+        self.mock_data_handler = Mock(spec=DataHandler)
+        self.mock_logger = Mock()
+
+        self.test_time = datetime(2023, 1, 1, 12, 0, 0)
+        self.mock_data_handler.get_latest_bar_datetime.return_value = self.test_time
+
+        self.patcher = patch("bbstrader.btengine.execution.Account")
+        MockAccount = self.patcher.start()
+
+        self.mock_account_instance = MockAccount.return_value
+
+        self.handler = MT5ExecutionHandler(
+            events=self.events_queue,
+            data=self.mock_data_handler,
+            logger=self.mock_logger,
+        )
+
+    def tearDown(self):
+        """Stop the patcher after each test."""
+        self.patcher.stop()
+
+    def test_execute_order_us_stock(self):
+        """Tests commission calculation for a US stock."""
+        symbol, qty, price = "AAPL", 100, 150.0
+
+        self.mock_account_instance.get_symbol_type.return_value = SymbolType.STOCKS
+        self.mock_account_instance.get_symbol_info.return_value = SymbolInfo(
+            1, 0.01, 1000
+        )
+        self.mock_account_instance.get_stocks_from_country.return_value = [symbol]
+
+        order_event = OrderEvent(symbol, "MKT", qty, "BUY", price, "LONG")
+        self.handler.execute_order(order_event)
+
+        fill_event = self.events_queue.get_nowait()
+
+        expected_commission = max(1.0, 100 * 0.02)  # 2.0
+        self.assertEqual(fill_event.commission, expected_commission)
+        self.assertEqual(fill_event.exchange, "MT5")
+
+    def test_execute_order_forex(self):
+        """Tests commission calculation for a Forex pair."""
+        symbol, qty, price = "EURUSD", 10000, 1.05
+
+        self.mock_account_instance.get_symbol_type.return_value = SymbolType.FOREX
+        self.mock_account_instance.get_symbol_info.return_value = SymbolInfo(
+            100000, 0.01, 1000
+        )
+
+        order_event = OrderEvent(symbol, "MKT", qty, "BUY", price, "LONG")
+        self.handler.execute_order(order_event)
+
+        fill_event = self.events_queue.get_nowait()
+
+        # lot = 10000 * 1.05 / 100000 = 0.105
+        # round(0.105, 2) is 0.10 (round half to even)
+        # commission = 3.0 * 0.10 = 0.3
+        expected_commission = 0.3
+        self.assertAlmostEqual(fill_event.commission, expected_commission)
+
+    def test_execute_order_commodity(self):
+        """Tests commission calculation for a Commodity."""
+        symbol, qty, price = "XAUUSD", 10, 1800
+
+        self.mock_account_instance.get_symbol_type.return_value = SymbolType.COMMODITIES
+        self.mock_account_instance.get_symbol_info.return_value = SymbolInfo(
+            100, 0.01, 1000
+        )
+
+        order_event = OrderEvent(symbol, "MKT", qty, "BUY", price, "LONG")
+        self.handler.execute_order(order_event)
+
+        fill_event = self.events_queue.get_nowait()
+
+        expected_commission = 3.0 * 0.1
+        self.assertAlmostEqual(fill_event.commission, expected_commission)
+
+    def test_execute_order_index(self):
+        """Tests commission calculation for an Index."""
+        symbol, qty, price = "GER30", 10, 15000
+
+        self.mock_account_instance.get_symbol_type.return_value = SymbolType.INDICES
+        self.mock_account_instance.get_symbol_info.return_value = SymbolInfo(1, 0.1, 50)
+
+        order_event = OrderEvent(symbol, "MKT", qty, "BUY", price, "LONG")
+        self.handler.execute_order(order_event)
+
+        fill_event = self.events_queue.get_nowait()
+
+        expected_commission = 0.25 * 10
+        self.assertAlmostEqual(fill_event.commission, expected_commission)
+
+    def test_lot_capping_at_minimum(self):
+        """Tests that lot size is floored at the symbol's volume_min."""
+        symbol, qty, price = "EURUSD", 100, 1.05
+
+        self.mock_account_instance.get_symbol_type.return_value = SymbolType.FOREX
+        self.mock_account_instance.get_symbol_info.return_value = SymbolInfo(
+            100000, 0.01, 1000
+        )
+
+        order_event = OrderEvent(symbol, "MKT", qty, "BUY", price, "LONG")
+        self.handler.execute_order(order_event)
+
+        fill_event = self.events_queue.get_nowait()
+
+        expected_commission = 3.0 * 0.01
+        self.assertAlmostEqual(fill_event.commission, expected_commission)
+
+    def test_custom_commission_overrides_calculation(self):
+        """Tests that a provided commission value overrides the calculated one."""
+        handler_with_commission = MT5ExecutionHandler(
+            events=self.events_queue, data=self.mock_data_handler, commission=99.99
+        )
+
+        symbol, qty, price = "AAPL", 100, 150.0
+        self.mock_account_instance.get_symbol_type.return_value = SymbolType.STOCKS
+        self.mock_account_instance.get_symbol_info.return_value = SymbolInfo(
+            1, 0.01, 1000
+        )
+        self.mock_account_instance.get_stocks_from_country.return_value = [symbol]
+
+        order_event = OrderEvent(symbol, "MKT", qty, "BUY", price, "LONG")
+        handler_with_commission.execute_order(order_event)
+
+        fill_event = self.events_queue.get_nowait()
+
+        self.assertEqual(fill_event.commission, 99.99)
+
+
+if __name__ == "__main__":
+    unittest.main()