def setUp(self): # Fixture Setup clock = TestClock() logger = TestLogger(clock) self.trader_id = TraderId("TESTER", "000") self.strategy = TradingStrategy(order_id_tag="001") self.strategy.register_trader( TraderId("TESTER", "000"), clock, logger, ) config = { 'host': 'localhost', 'port': 6379, } self.database = RedisExecutionDatabase( trader_id=self.trader_id, logger=logger, command_serializer=MsgPackCommandSerializer(), event_serializer=MsgPackEventSerializer(), config=config, ) self.test_redis = redis.Redis(host="localhost", port=6379, db=0)
def setUp(self): # Fixture Setup clock = TestClock() logger = TestLogger() self.trader_id = TraderId('TESTER', '000') self.strategy = EmptyStrategy(order_id_tag='001') self.strategy.change_clock(clock) self.strategy.change_logger(logger) self.database = RedisExecutionDatabase( trader_id=self.trader_id, host='localhost', port=6379, command_serializer=MsgPackCommandSerializer(), event_serializer=MsgPackEventSerializer(), logger=logger) self.test_redis = redis.Redis(host='localhost', port=6379, db=0)
def setup(self): # Fixture Setup self.clock = TestClock() self.logger = Logger(self.clock) self.trader_id = TraderId("TESTER-000") self.strategy = TradingStrategy(order_id_tag="001") self.strategy.register_trader(self.trader_id, self.clock, self.logger) config = { "host": "localhost", "port": 6379, } self.database = RedisCacheDatabase( trader_id=self.trader_id, logger=self.logger, instrument_serializer=MsgPackInstrumentSerializer(), command_serializer=MsgPackCommandSerializer(), event_serializer=MsgPackEventSerializer(), config=config, ) self.test_redis = redis.Redis(host="localhost", port=6379, db=0)
def __init__( self, strategies: List[TradingStrategy], config: Dict[str, object], ): """ Initialize a new instance of the TradingNode class. Parameters ---------- strategies : list[TradingStrategy] The list of strategies to run on the trading node. config : dict[str, object] The configuration for the trading node. Raises ------ ValueError If strategies is None or empty. ValueError If config is None or empty. """ PyCondition.not_none(strategies, "strategies") PyCondition.not_none(config, "config") PyCondition.not_empty(strategies, "strategies") PyCondition.not_empty(config, "config") # Extract configs config_trader = config.get("trader", {}) config_log = config.get("logging", {}) config_exec_db = config.get("exec_database", {}) config_strategy = config.get("strategy", {}) config_adapters = config.get("adapters", {}) self._uuid_factory = UUIDFactory() self._loop = asyncio.get_event_loop() self._executor = concurrent.futures.ThreadPoolExecutor() self._loop.set_default_executor(self._executor) self._clock = LiveClock(loop=self._loop) self.created_time = self._clock.utc_now() self._is_running = False # Uncomment for debugging # self._loop.set_debug(True) # Setup identifiers self.trader_id = TraderId( name=config_trader["name"], tag=config_trader["id_tag"], ) # Setup logging self._logger = LiveLogger( clock=self._clock, name=self.trader_id.value, level_console=LogLevelParser.from_str_py(config_log.get("log_level_console")), level_file=LogLevelParser.from_str_py(config_log.get("log_level_file")), level_store=LogLevelParser.from_str_py(config_log.get("log_level_store")), run_in_process=config_log.get("run_in_process", True), # Run logger in a separate process log_thread=config_log.get("log_thread_id", False), log_to_file=config_log.get("log_to_file", False), log_file_path=config_log.get("log_file_path", ""), ) self._log = LoggerAdapter(component_name=self.__class__.__name__, logger=self._logger) self._log_header() self._log.info("Building...") self._setup_loop() # Requires the logger to be initialized self.portfolio = Portfolio( clock=self._clock, logger=self._logger, ) self._data_engine = LiveDataEngine( loop=self._loop, portfolio=self.portfolio, clock=self._clock, logger=self._logger, config={"qsize": 10000}, ) self.portfolio.register_cache(self._data_engine.cache) self.analyzer = PerformanceAnalyzer() if config_exec_db["type"] == "redis": exec_db = RedisExecutionDatabase( trader_id=self.trader_id, logger=self._logger, command_serializer=MsgPackCommandSerializer(), event_serializer=MsgPackEventSerializer(), config={ "host": config_exec_db["host"], "port": config_exec_db["port"], } ) else: exec_db = BypassExecutionDatabase( trader_id=self.trader_id, logger=self._logger, ) self._exec_engine = LiveExecutionEngine( loop=self._loop, database=exec_db, portfolio=self.portfolio, clock=self._clock, logger=self._logger, config={"qsize": 10000}, ) self._exec_engine.load_cache() self._setup_adapters(config_adapters, self._logger) self.trader = Trader( trader_id=self.trader_id, strategies=strategies, portfolio=self.portfolio, data_engine=self._data_engine, exec_engine=self._exec_engine, clock=self._clock, logger=self._logger, ) self._check_residuals_delay = config_trader.get("check_residuals_delay", 5.0) self._load_strategy_state = config_strategy.get("load_state", True) self._save_strategy_state = config_strategy.get("save_state", True) if self._load_strategy_state: self.trader.load() self._log.info("state=INITIALIZED.") self.time_to_initialize = self._clock.delta(self.created_time) self._log.info(f"Initialized in {self.time_to_initialize.total_seconds():.3f}s.")
def __init__( self, strategies: List[TradingStrategy], config: Dict[str, object], ): """ Initialize a new instance of the TradingNode class. Parameters ---------- strategies : list[TradingStrategy] The list of strategies to run on the trading node. config : dict[str, object] The configuration for the trading node. """ if strategies is None: strategies = [] config_trader = config.get("trader", {}) config_log = config.get("logging", {}) config_exec_db = config.get("exec_database", {}) config_strategy = config.get("strategy", {}) config_data_clients = config.get("data_clients", {}) config_exec_clients = config.get("exec_clients", {}) self._clock = LiveClock() self._uuid_factory = UUIDFactory() self._loop = asyncio.get_event_loop() self._executor = concurrent.futures.ThreadPoolExecutor() self._loop.set_default_executor(self._executor) self._loop.set_debug(False) # TODO: Development self._is_running = False # Setup identifiers self.trader_id = TraderId( name=config_trader["name"], tag=config_trader["id_tag"], ) # Setup logging logger = LiveLogger( clock=self._clock, name=self.trader_id.value, level_console=LogLevelParser.from_str_py( config_log.get("log_level_console")), level_file=LogLevelParser.from_str_py( config_log.get("log_level_file")), level_store=LogLevelParser.from_str_py( config_log.get("log_level_store")), log_thread=config_log.get("log_thread_id", True), log_to_file=config_log.get("log_to_file", False), log_file_path=config_log.get("log_file_path", ""), ) self._log = LoggerAdapter(component_name=self.__class__.__name__, logger=logger) self._log_header() self._log.info("Building...") self.portfolio = Portfolio( clock=self._clock, logger=logger, ) self._data_engine = LiveDataEngine( loop=self._loop, portfolio=self.portfolio, clock=self._clock, logger=logger, ) self.portfolio.register_cache(self._data_engine.cache) self.analyzer = PerformanceAnalyzer() if config_exec_db["type"] == "redis": exec_db = RedisExecutionDatabase( trader_id=self.trader_id, logger=logger, command_serializer=MsgPackCommandSerializer(), event_serializer=MsgPackEventSerializer(), config={ "host": config_exec_db["host"], "port": config_exec_db["port"], }) else: exec_db = BypassExecutionDatabase( trader_id=self.trader_id, logger=logger, ) self._exec_engine = LiveExecutionEngine( loop=self._loop, database=exec_db, portfolio=self.portfolio, clock=self._clock, logger=logger, ) self._exec_engine.load_cache() self._setup_data_clients(config_data_clients, logger) self._setup_exec_clients(config_exec_clients, logger) self.trader = Trader( trader_id=self.trader_id, strategies=strategies, data_engine=self._data_engine, exec_engine=self._exec_engine, clock=self._clock, logger=logger, ) self._check_residuals_delay = 2.0 # Hard coded delay (refactor) self._load_strategy_state = config_strategy.get("load_state", True) self._save_strategy_state = config_strategy.get("save_state", True) if self._load_strategy_state: self.trader.load() self._setup_loop() self._log.info("state=INITIALIZED.")
def setUp(self): # Fixture Setup self.account_id = TestStubs.account_id() self.serializer = MsgPackEventSerializer()
class MsgPackEventSerializerTests(unittest.TestCase): def setUp(self): # Fixture Setup self.account_id = TestStubs.account_id() self.serializer = MsgPackEventSerializer() def test_serialize_and_deserialize_account_state_events(self): # Arrange event = AccountState( account_id=AccountId("SIM", "000"), balances=[Money(1525000, USD)], balances_free=[Money(1425000, USD)], balances_locked=[Money(0, USD)], info={"default_currency": "USD"}, event_id=uuid4(), event_timestamp=UNIX_EPOCH, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert self.assertEqual(deserialized, event) def test_serialize_and_deserialize_order_initialized_events(self): # Arrange options = {'Price': '1.0005'} event = OrderInitialized( ClientOrderId("O-123456"), StrategyId("S", "001"), AUDUSD_SIM.symbol, OrderSide.SELL, OrderType.STOP_MARKET, Quantity(100000), TimeInForce.DAY, uuid4(), UNIX_EPOCH, options=options, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert self.assertEqual(deserialized, event) self.assertEqual(options, event.options) def test_serialize_and_deserialize_order_submitted_events(self): # Arrange event = OrderSubmitted( self.account_id, ClientOrderId("O-123456"), UNIX_EPOCH, uuid4(), UNIX_EPOCH, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert self.assertEqual(deserialized, event) def test_serialize_and_deserialize_order_invalid_events(self): # Arrange event = OrderInvalid( ClientOrderId("O-123456"), "OrderId already exists", uuid4(), UNIX_EPOCH, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert self.assertEqual(deserialized, event) def test_serialize_and_deserialize_order_denied_events(self): # Arrange event = OrderDenied( ClientOrderId("O-123456"), "Exceeds risk for FX", uuid4(), UNIX_EPOCH, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert self.assertEqual(deserialized, event) def test_serialize_and_deserialize_order_accepted_events(self): # Arrange event = OrderAccepted( self.account_id, ClientOrderId("O-123456"), OrderId("B-123456"), UNIX_EPOCH, uuid4(), UNIX_EPOCH, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert self.assertEqual(deserialized, event) def test_serialize_and_deserialize_order_rejected_events(self): # Arrange event = OrderRejected( self.account_id, ClientOrderId("O-123456"), UNIX_EPOCH, "ORDER_ID_INVALID", uuid4(), UNIX_EPOCH, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert self.assertEqual(deserialized, event) def test_serialize_and_deserialize_order_working_events(self): # Arrange event = OrderWorking( self.account_id, ClientOrderId("O-123456"), OrderId("B-123456"), AUDUSD_SIM.symbol, OrderSide.SELL, OrderType.STOP_MARKET, Quantity(100000), Price("1.50000"), TimeInForce.DAY, None, UNIX_EPOCH, uuid4(), UNIX_EPOCH, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert self.assertEqual(deserialized, event) def test_serialize_and_deserialize_order_working_events_with_expire_time( self): # Arrange event = OrderWorking( self.account_id, ClientOrderId("O-123456"), OrderId("B-123456"), AUDUSD_SIM.symbol, OrderSide.SELL, OrderType.STOP_MARKET, Quantity(100000), Price("1.50000"), TimeInForce.DAY, UNIX_EPOCH, UNIX_EPOCH, uuid4(), UNIX_EPOCH, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert self.assertEqual(deserialized, event) def test_serialize_and_deserialize_order_cancelled_events(self): # Arrange event = OrderCancelled( self.account_id, ClientOrderId("O-123456"), OrderId("1"), UNIX_EPOCH, uuid4(), UNIX_EPOCH, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert self.assertEqual(deserialized, event) def test_serialize_and_deserialize_order_cancel_reject_events(self): # Arrange event = OrderCancelReject( self.account_id, ClientOrderId("O-123456"), UNIX_EPOCH, "RESPONSE", "ORDER_DOES_NOT_EXIST", uuid4(), UNIX_EPOCH, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert self.assertEqual(deserialized, event) def test_serialize_and_deserialize_order_modified_events(self): # Arrange event = OrderModified( self.account_id, ClientOrderId("O-123456"), OrderId("1"), Quantity(100000), Price("0.80010"), UNIX_EPOCH, uuid4(), UNIX_EPOCH, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert self.assertEqual(deserialized, event) def test_serialize_and_deserialize_order_expired_events(self): # Arrange event = OrderExpired( self.account_id, ClientOrderId("O-123456"), OrderId("1"), UNIX_EPOCH, uuid4(), UNIX_EPOCH, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert self.assertEqual(deserialized, event) def test_serialize_and_deserialize_order_partially_filled_events(self): # Arrange event = OrderFilled( self.account_id, ClientOrderId("O-123456"), OrderId("1"), ExecutionId("E123456"), PositionId("T123456"), StrategyId("S", "001"), AUDUSD_SIM.symbol, OrderSide.SELL, Quantity(50000), Quantity(50000), Quantity(50000), Price("1.00000"), AUDUSD_SIM.quote_currency, AUDUSD_SIM.is_inverse, Money(0, USD), LiquiditySide.MAKER, UNIX_EPOCH, uuid4(), UNIX_EPOCH, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert self.assertEqual(deserialized, event) def test_serialize_and_deserialize_order_filled_events(self): # Arrange event = OrderFilled( self.account_id, ClientOrderId("O-123456"), OrderId("1"), ExecutionId("E123456"), PositionId("T123456"), StrategyId("S", "001"), AUDUSD_SIM.symbol, OrderSide.SELL, Quantity(100000), Quantity(100000), Quantity(), Price("1.00000"), AUDUSD_SIM.quote_currency, AUDUSD_SIM.is_inverse, Money(0, USD), LiquiditySide.TAKER, UNIX_EPOCH, uuid4(), UNIX_EPOCH, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert self.assertEqual(deserialized, event)
def __init__( self, strategies: List[TradingStrategy], config: Dict[str, object], ): """ Initialize a new instance of the TradingNode class. Parameters ---------- strategies : list[TradingStrategy] The list of strategies to run on the trading node. config : dict[str, object] The configuration for the trading node. Raises ------ ValueError If strategies is None or empty. ValueError If config is None or empty. """ PyCondition.not_none(strategies, "strategies") PyCondition.not_none(config, "config") PyCondition.not_empty(strategies, "strategies") PyCondition.not_empty(config, "config") self._config = config # Extract configs config_trader = config.get("trader", {}) config_system = config.get("system", {}) config_log = config.get("logging", {}) config_exec_db = config.get("exec_database", {}) config_risk = config.get("risk", {}) config_strategy = config.get("strategy", {}) # System config self._connection_timeout = config_system.get("connection_timeout", 5.0) self._disconnection_timeout = config_system.get( "disconnection_timeout", 5.0) self._check_residuals_delay = config_system.get( "check_residuals_delay", 5.0) self._load_strategy_state = config_strategy.get("load_state", True) self._save_strategy_state = config_strategy.get("save_state", True) # Setup loop self._loop = asyncio.get_event_loop() self._executor = concurrent.futures.ThreadPoolExecutor() self._loop.set_default_executor(self._executor) self._loop.set_debug(config_system.get("loop_debug", False)) # Components self._clock = LiveClock(loop=self._loop) self._uuid_factory = UUIDFactory() self.system_id = self._uuid_factory.generate() self.created_time = self._clock.utc_now() self._is_running = False # Setup identifiers self.trader_id = TraderId( name=config_trader["name"], tag=config_trader["id_tag"], ) # Setup logging level_stdout = LogLevelParser.from_str_py( config_log.get("level_stdout")) self._logger = LiveLogger( loop=self._loop, clock=self._clock, trader_id=self.trader_id, system_id=self.system_id, level_stdout=level_stdout, ) self._log = LoggerAdapter( component=self.__class__.__name__, logger=self._logger, ) self._log_header() self._log.info("Building...") if platform.system() != "Windows": # Requires the logger to be initialized # Windows does not support signal handling # https://stackoverflow.com/questions/45987985/asyncio-loops-add-signal-handler-in-windows self._setup_loop() # Build platform # ---------------------------------------------------------------------- self.portfolio = Portfolio( clock=self._clock, logger=self._logger, ) self._data_engine = LiveDataEngine( loop=self._loop, portfolio=self.portfolio, clock=self._clock, logger=self._logger, config={"qsize": 10000}, ) self.portfolio.register_cache(self._data_engine.cache) self.analyzer = PerformanceAnalyzer() if config_exec_db["type"] == "redis": exec_db = RedisExecutionDatabase( trader_id=self.trader_id, logger=self._logger, command_serializer=MsgPackCommandSerializer(), event_serializer=MsgPackEventSerializer(), config={ "host": config_exec_db["host"], "port": config_exec_db["port"], }, ) else: exec_db = BypassExecutionDatabase( trader_id=self.trader_id, logger=self._logger, ) self._exec_engine = LiveExecutionEngine( loop=self._loop, database=exec_db, portfolio=self.portfolio, clock=self._clock, logger=self._logger, config={"qsize": 10000}, ) self._risk_engine = LiveRiskEngine( loop=self._loop, exec_engine=self._exec_engine, portfolio=self.portfolio, clock=self._clock, logger=self._logger, config=config_risk, ) self._exec_engine.load_cache() self._exec_engine.register_risk_engine(self._risk_engine) self.trader = Trader( trader_id=self.trader_id, strategies=strategies, portfolio=self.portfolio, data_engine=self._data_engine, exec_engine=self._exec_engine, risk_engine=self._risk_engine, clock=self._clock, logger=self._logger, ) if self._load_strategy_state: self.trader.load() self._builder = TradingNodeBuilder( data_engine=self._data_engine, exec_engine=self._exec_engine, risk_engine=self._risk_engine, clock=self._clock, logger=self._logger, log=self._log, ) self._log.info("state=INITIALIZED.") self.time_to_initialize = self._clock.delta(self.created_time) self._log.info( f"Initialized in {self.time_to_initialize.total_seconds():.3f}s.") self._is_built = False
def setUp(self): # Fixture Setup trader_id = TraderId('TESTER', '000') account_id = TestStubs.account_id() clock = LiveClock() guid_factory = LiveGuidFactory() logger = LiveLogger() self.command_server = MessageServer( server_id=ServerId("CommandServer-001"), recv_port=TEST_COMMANDS_REQ_PORT, send_port=TEST_COMMANDS_REP_PORT, header_serializer=MsgPackDictionarySerializer(), request_serializer=MsgPackRequestSerializer(), response_serializer=MsgPackResponseSerializer(), compressor=CompressorBypass(), encryption=EncryptionSettings(), clock=clock, guid_factory=guid_factory, logger=LoggerAdapter('CommandServer', logger)) self.command_serializer = MsgPackCommandSerializer() self.command_server_sink = [] self.command_server.register_handler(MessageType.COMMAND, self.command_handler) self.command_server.start() time.sleep(0.1) self.portfolio = Portfolio( currency=Currency.USD, clock=clock, guid_factory=guid_factory, logger=logger) self.analyzer = PerformanceAnalyzer() self.exec_db = InMemoryExecutionDatabase( trader_id=trader_id, logger=logger) self.exec_engine = LiveExecutionEngine( trader_id=trader_id, account_id=account_id, database=self.exec_db, portfolio=self.portfolio, clock=clock, guid_factory=guid_factory, logger=logger) self.exec_engine.handle_event(TestStubs.account_event()) self.exec_client = LiveExecClient( exec_engine=self.exec_engine, host=LOCALHOST, command_req_port=TEST_COMMANDS_REQ_PORT, command_res_port=TEST_COMMANDS_REP_PORT, event_pub_port=TEST_EVENTS_PUB_PORT, compressor=CompressorBypass(), encryption=EncryptionSettings(), command_serializer=MsgPackCommandSerializer(), header_serializer=MsgPackDictionarySerializer(), request_serializer=MsgPackRequestSerializer(), response_serializer=MsgPackResponseSerializer(), event_serializer=MsgPackEventSerializer(), clock=clock, guid_factory=guid_factory, logger=logger) self.exec_engine.register_client(self.exec_client) self.exec_client.connect() time.sleep(0.1) self.bar_type = TestStubs.bartype_audusd_1min_bid() self.strategy = TestStrategy1(self.bar_type, id_tag_strategy='001') self.strategy.change_logger(logger) self.exec_engine.register_strategy(self.strategy)
class TestMsgPackEventSerializer: def setup(self): # Fixture Setup self.account_id = TestStubs.account_id() self.serializer = MsgPackEventSerializer() def test_serialize_and_deserialize_account_state_events(self): # Arrange event = AccountState( account_id=AccountId("SIM", "000"), balances=[Money(1525000, USD)], balances_free=[Money(1425000, USD)], balances_locked=[Money(0, USD)], info={"default_currency": "USD"}, event_id=uuid4(), timestamp_ns=0, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert assert deserialized == event def test_serialize_and_deserialize_market_order_initialized_events(self): # Arrange event = OrderInitialized( ClientOrderId("O-123456"), StrategyId("S", "001"), AUDUSD_SIM.id, OrderSide.SELL, OrderType.MARKET, Quantity(100000), TimeInForce.FOK, uuid4(), 0, options={}, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert assert deserialized == event def test_serialize_and_deserialize_limit_order_initialized_events(self): # Arrange options = { "ExpireTime": None, "Price": "1.0010", "PostOnly": True, "ReduceOnly": True, "Hidden": False, } event = OrderInitialized( ClientOrderId("O-123456"), StrategyId("S", "001"), AUDUSD_SIM.id, OrderSide.SELL, OrderType.LIMIT, Quantity(100000), TimeInForce.DAY, uuid4(), 0, options=options, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert assert deserialized == event assert deserialized.options == options def test_serialize_and_deserialize_stop_market_order_initialized_events( self): # Arrange options = { "ExpireTime": None, "Price": "1.0005", "ReduceOnly": False, } event = OrderInitialized( ClientOrderId("O-123456"), StrategyId("S", "001"), AUDUSD_SIM.id, OrderSide.SELL, OrderType.STOP_MARKET, Quantity(100000), TimeInForce.DAY, uuid4(), 0, options=options, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert assert deserialized == event assert deserialized.options == options def test_serialize_and_deserialize_stop_limit_order_initialized_events( self): # Arrange options = { "ExpireTime": None, "Price": "1.0005", "Trigger": "1.0010", "PostOnly": True, "ReduceOnly": False, "Hidden": False, } event = OrderInitialized( ClientOrderId("O-123456"), StrategyId("S", "001"), AUDUSD_SIM.id, OrderSide.SELL, OrderType.STOP_LIMIT, Quantity(100000), TimeInForce.DAY, uuid4(), 0, options=options, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert assert deserialized == event assert deserialized.options == options def test_serialize_and_deserialize_order_submitted_events(self): # Arrange event = OrderSubmitted( self.account_id, ClientOrderId("O-123456"), 0, uuid4(), 0, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert assert deserialized == event def test_serialize_and_deserialize_order_invalid_events(self): # Arrange event = OrderInvalid( ClientOrderId("O-123456"), "VenueOrderId already exists", uuid4(), 0, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert assert deserialized == event def test_serialize_and_deserialize_order_denied_events(self): # Arrange event = OrderDenied( ClientOrderId("O-123456"), "Exceeds risk for FX", uuid4(), 0, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert assert deserialized == event def test_serialize_and_deserialize_order_accepted_events(self): # Arrange event = OrderAccepted( self.account_id, ClientOrderId("O-123456"), VenueOrderId("B-123456"), 0, uuid4(), 0, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert assert deserialized == event def test_serialize_and_deserialize_order_rejected_events(self): # Arrange event = OrderRejected( self.account_id, ClientOrderId("O-123456"), 0, "ORDER_ID_INVALID", uuid4(), 0, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert assert deserialized == event def test_serialize_and_deserialize_order_cancelled_events(self): # Arrange event = OrderCancelled( self.account_id, ClientOrderId("O-123456"), VenueOrderId("1"), 0, uuid4(), 0, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert assert deserialized == event def test_serialize_and_deserialize_order_update_reject_events(self): # Arrange event = OrderUpdateRejected( self.account_id, ClientOrderId("O-123456"), VenueOrderId("1"), 0, "RESPONSE", "ORDER_DOES_NOT_EXIST", uuid4(), 0, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert assert deserialized == event def test_serialize_and_deserialize_order_cancel_reject_events(self): # Arrange event = OrderCancelRejected( self.account_id, ClientOrderId("O-123456"), VenueOrderId("1"), 0, "RESPONSE", "ORDER_DOES_NOT_EXIST", uuid4(), 0, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert assert deserialized == event def test_serialize_and_deserialize_order_amended_events(self): # Arrange event = OrderUpdated( self.account_id, ClientOrderId("O-123456"), VenueOrderId("1"), Quantity(100000), Price("0.80010"), 0, uuid4(), 0, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert assert deserialized == event def test_serialize_and_deserialize_order_expired_events(self): # Arrange event = OrderExpired( self.account_id, ClientOrderId("O-123456"), VenueOrderId("1"), 0, uuid4(), 0, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert assert deserialized == event def test_serialize_and_deserialize_order_partially_filled_events(self): # Arrange event = OrderFilled( self.account_id, ClientOrderId("O-123456"), VenueOrderId("1"), ExecutionId("E123456"), PositionId("T123456"), StrategyId("S", "001"), AUDUSD_SIM.id, OrderSide.SELL, Quantity(50000), Price("1.00000"), Quantity(50000), Quantity(50000), AUDUSD_SIM.quote_currency, AUDUSD_SIM.is_inverse, Money(0, USD), LiquiditySide.MAKER, 0, uuid4(), 0, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert assert deserialized == event def test_serialize_and_deserialize_order_filled_events(self): # Arrange event = OrderFilled( self.account_id, ClientOrderId("O-123456"), VenueOrderId("1"), ExecutionId("E123456"), PositionId("T123456"), StrategyId("S", "001"), AUDUSD_SIM.id, OrderSide.SELL, Quantity(100000), Price("1.00000"), Quantity(100000), Quantity(), AUDUSD_SIM.quote_currency, AUDUSD_SIM.is_inverse, Money(0, USD), LiquiditySide.TAKER, 0, uuid4(), 0, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert assert deserialized == event