def test_generate_order_fills_report(self):
# Arrange
report_provider = ReportProvider()
order1 = self.order_factory.limit(AUDUSD_FXCM, OrderSide.BUY,
Quantity(1500000), Price(0.80010, 5))
order2 = self.order_factory.limit(AUDUSD_FXCM, OrderSide.SELL,
Quantity(1500000), Price(0.80000, 5))
event = OrderFilled(self.account_id, order1.id,
ExecutionId('SOME_EXEC_ID_1'),
PositionIdBroker('SOME_EXEC_TICKET_1'),
order1.symbol, order1.side, order1.quantity,
Price(0.80011, 5), Currency.AUD, UNIX_EPOCH,
GUID(uuid.uuid4()), UNIX_EPOCH)
order1.apply(event)
orders = {order1.id: order1, order2.id: order2}
# Act
report = report_provider.generate_order_fills_report(orders)
# Assert
# print(report.iloc[0])
self.assertEqual(1, len(report))
self.assertEqual('order_id', report.index.name)
self.assertEqual(order1.id.value, report.index[0])
self.assertEqual('AUDUSD', report.iloc[0]['symbol'])
self.assertEqual('BUY', report.iloc[0]['side'])
self.assertEqual('LIMIT', report.iloc[0]['type'])
self.assertEqual(1500000, report.iloc[0]['quantity'])
self.assertAlmostEqual(0.80011, report.iloc[0]['avg_price'])
self.assertEqual(0.00001, report.iloc[0]['slippage'])
def test_position_filled_with_buy_order_returns_expected_attributes(self):
# Arrange
order = self.order_factory.market(
AUDUSD_FXCM,
OrderSide.BUY,
Quantity(100000))
order_filled = OrderFilled(
self.account_id,
order.id,
ExecutionId('E123456'),
PositionIdBroker('T123456'),
order.symbol,
order.side,
order.quantity,
Price(1.00001, 5),
Currency.USD,
UNIX_EPOCH,
GUID(uuid.uuid4()),
UNIX_EPOCH)
last = Tick(AUDUSD_FXCM,
Price(1.00050, 5),
Price(1.00048, 5),
Volume(1),
Volume(1),
UNIX_EPOCH)
# Act
position = Position(PositionId('P-123456'), order_filled)
# Assert
self.assertEqual(OrderId('O-19700101-000000-001-001-1'), position.from_order_id)
self.assertEqual(Quantity(100000), position.quantity)
self.assertEqual(Quantity(100000), position.peak_quantity)
self.assertEqual(OrderSide.BUY, position.entry_direction)
self.assertEqual(MarketPosition.LONG, position.market_position)
self.assertEqual(UNIX_EPOCH, position.opened_time)
self.assertIsNone(position.open_duration)
self.assertEqual(1.00001, position.average_open_price)
self.assertEqual(1, position.event_count)
self.assertEqual([order.id], position.get_order_ids())
self.assertEqual([ExecutionId('E123456')], position.get_execution_ids())
self.assertEqual(ExecutionId('E123456'), position.last_execution_id)
self.assertEqual(PositionIdBroker('T123456'), position.id_broker)
self.assertTrue(position.is_long)
self.assertFalse(position.is_short)
self.assertFalse(position.is_closed)
self.assertEqual(0.0, position.realized_points)
self.assertEqual(0.0, position.realized_return)
self.assertEqual(Money(0, Currency.USD), position.realized_pnl)
self.assertEqual(0.0004899999999998794, position.unrealized_points(last))
self.assertEqual(0.0004899951000488789, position.unrealized_return(last))
self.assertEqual(Money(49.00, Currency.USD), position.unrealized_pnl(last))
self.assertEqual(0.0004899999999998794, position.total_points(last))
self.assertEqual(0.0004899951000488789, position.total_return(last))
self.assertEqual(Money(49.00, Currency.USD), position.total_pnl(last))
def test_can_hash_time_event(self):
# Arrange
event = TimeEvent(Label('123'), GUID(uuid.uuid4()), UNIX_EPOCH)
# Act
result = hash(event)
# Assert
self.assertEqual(int, type(result)) # No assertions raised
def test_position_filled_with_sell_order_returns_expected_attributes(self):
# Arrange
order = self.order_factory.market(
AUDUSD_FXCM,
OrderSide.SELL,
Quantity(100000))
order_filled = OrderFilled(
self.account_id,
order.id,
ExecutionId('E123456'),
PositionIdBroker('T123456'),
order.symbol,
order.side,
order.quantity,
Price(1.00001, 5),
Currency.USD,
UNIX_EPOCH,
GUID(uuid.uuid4()),
UNIX_EPOCH)
last = Tick(AUDUSD_FXCM,
Price(1.00050, 5),
Price(1.00048, 5),
Volume(1),
Volume(1),
UNIX_EPOCH)
# Act
position = Position(PositionId('P-123456'), order_filled)
# Assert
self.assertEqual(Quantity(100000), position.quantity)
self.assertEqual(Quantity(100000), position.peak_quantity)
self.assertEqual(MarketPosition.SHORT, position.market_position)
self.assertEqual(UNIX_EPOCH, position.opened_time)
self.assertEqual(1.00001, position.average_open_price)
self.assertEqual(1, position.event_count)
self.assertEqual(ExecutionId('E123456'), position.last_execution_id)
self.assertEqual(PositionIdBroker('T123456'), position.id_broker)
self.assertFalse(position.is_long)
self.assertTrue(position.is_short)
self.assertFalse(position.is_closed)
self.assertEqual(0.0, position.realized_points)
self.assertEqual(0.0, position.realized_return)
self.assertEqual(Money(0, Currency.USD), position.realized_pnl)
self.assertEqual(-0.00046999999999997044, position.unrealized_points(last))
self.assertEqual(-0.0004699953000469699, position.unrealized_return(last))
self.assertEqual(Money(-47.00, Currency.USD), position.unrealized_pnl(last))
self.assertEqual(-0.00046999999999997044, position.total_points(last))
self.assertEqual(-0.0004699953000469699, position.total_return(last))
self.assertEqual(Money(-47.00, Currency.USD), position.total_pnl(last))
def test_stop_order_with_zero_price_input_raises_exception(self):
# Arrange
# Act
self.assertRaises(ValueError,
Order,
OrderId('O-123456'),
AUDUSD_FXCM,
OrderSide.BUY,
OrderType.STOP,
Quantity(100000),
GUID(uuid.uuid4()),
UNIX_EPOCH,
price=None)
def test_market_order_with_price_input_raises_exception(self):
# Arrange
# Act
self.assertRaises(ValueError,
Order,
OrderId('O-123456'),
AUDUSD_FXCM,
OrderSide.BUY,
OrderType.MARKET,
Quantity(100000),
GUID(uuid.uuid4()),
UNIX_EPOCH,
price=Price(1.00000, 5))
def test_can_apply_order_cancelled_event_to_order(self):
# Arrange
order = self.order_factory.market(AUDUSD_FXCM, OrderSide.BUY,
Quantity(100000))
event = OrderCancelled(self.account_id, order.id, UNIX_EPOCH,
GUID(uuid.uuid4()), UNIX_EPOCH)
# Act
order.apply(event)
# Assert
self.assertEqual(OrderState.CANCELLED, order.state)
self.assertTrue(order.is_completed)
def test_can_apply_order_cancel_reject_event_to_order(self):
# Arrange
order = self.order_factory.market(AUDUSD_FXCM, OrderSide.BUY,
Quantity(100000))
event = OrderCancelReject(self.account_id, order.id, UNIX_EPOCH,
ValidString('REJECT_RESPONSE'),
ValidString('ORDER DOES NOT EXIST'),
GUID(uuid.uuid4()), UNIX_EPOCH)
# Act
order.apply(event)
# Assert
self.assertEqual(OrderState.INITIALIZED, order.state)
def test_can_apply_order_accepted_event_to_order(self):
# Arrange
order = self.order_factory.market(AUDUSD_FXCM, OrderSide.BUY,
Quantity(100000))
event = OrderAccepted(self.account_id, order.id,
OrderIdBroker('B' + order.id.value), Label('E'),
UNIX_EPOCH, GUID(uuid.uuid4()), UNIX_EPOCH)
# Act
order.apply(event)
# Assert
self.assertEqual(OrderState.ACCEPTED, order.state)
self.assertFalse(order.is_completed)
def test_can_apply_order_rejected_event_to_order(self):
# Arrange
order = self.order_factory.market(AUDUSD_FXCM, OrderSide.BUY,
Quantity(100000))
event = OrderRejected(self.account_id, order.id, UNIX_EPOCH,
ValidString('ORDER ID INVALID'),
GUID(uuid.uuid4()), UNIX_EPOCH)
# Act
order.apply(event)
# Assert
self.assertEqual(OrderState.REJECTED, order.state)
self.assertTrue(order.is_completed)
def test_can_apply_order_submitted_event_to_order(self):
# Arrange
order = self.order_factory.market(AUDUSD_FXCM, OrderSide.BUY,
Quantity(100000))
event = OrderSubmitted(self.account_id, order.id, UNIX_EPOCH,
GUID(uuid.uuid4()), UNIX_EPOCH)
# Act
order.apply(event)
# Assert
self.assertEqual(OrderState.SUBMITTED, order.state)
self.assertEqual(2, order.event_count)
self.assertEqual(event, order.last_event)
self.assertFalse(order.is_completed)
def test_can_add_account(self):
# Arrange
event = AccountStateEvent(
AccountId.py_from_string('SIMULATED-123456-SIMULATED'),
Currency.USD, Money(1000000, Currency.USD),
Money(1000000, Currency.USD), Money(0, Currency.USD),
Money(0, Currency.USD), Money(0, Currency.USD), Decimal(0),
ValidString('N'), GUID(uuid.uuid4()), UNIX_EPOCH)
account = Account(event)
# Act
self.database.add_account(account)
# Assert
self.assertTrue(True) # Did not raise exception
def test_priced_order_with_GTD_time_in_force_and_expire_time_none_raises_exception(
self):
# Arrange
# Act
self.assertRaises(ValueError,
Order,
OrderId('O-123456'),
AUDUSD_FXCM,
OrderSide.BUY,
OrderType.LIMIT,
Quantity(100000),
GUID(uuid.uuid4()),
UNIX_EPOCH,
price=Price(1.00000, 5),
time_in_force=TimeInForce.GTD,
expire_time=None)
def test_can_apply_order_overfilled_event_to_buy_limit_order(self):
# Arrange
order = self.order_factory.limit(AUDUSD_FXCM, OrderSide.BUY,
Quantity(100000), Price(1.00000, 5))
event = OrderFilled(self.account_id, order.id,
ExecutionId('SOME_EXEC_ID_1'),
PositionIdBroker('SOME_EXEC_TICKET_1'),
order.symbol, order.side, Quantity(150000),
Price(0.99999, 5), Currency.USD, UNIX_EPOCH,
GUID(uuid.uuid4()), UNIX_EPOCH)
# Act
order.apply(event)
# Assert
self.assertEqual(OrderState.OVER_FILLED, order.state)
self.assertEqual(Quantity(150000), order.filled_quantity)
self.assertFalse(order.is_completed)
self.assertEqual(UNIX_EPOCH, order.filled_timestamp)
def test_can_apply_order_filled_event_to_market_order(self):
# Arrange
order = self.order_factory.market(AUDUSD_FXCM, OrderSide.BUY,
Quantity(100000))
event = OrderFilled(self.account_id, order.id,
ExecutionId('SOME_EXEC_ID_1'),
PositionIdBroker('SOME_EXEC_TICKET_1'),
order.symbol, order.side, order.quantity,
Price(1.00001, 5), Currency.USD, UNIX_EPOCH,
GUID(uuid.uuid4()), UNIX_EPOCH)
# Act
order.apply(event)
# Assert
self.assertEqual(OrderState.FILLED, order.state)
self.assertEqual(Quantity(100000), order.filled_quantity)
self.assertEqual(Price(1.00001, 5), order.average_price)
self.assertTrue(order.is_completed)
self.assertEqual(UNIX_EPOCH, order.filled_timestamp)
def test_can_apply_order_working_event_to_order(self):
# Arrange
order = self.order_factory.market(AUDUSD_FXCM, OrderSide.BUY,
Quantity(100000))
event = OrderWorking(self.account_id, order.id,
OrderIdBroker('SOME_BROKER_ID'), order.symbol,
order.label,
order.side, order.type, order.quantity,
Price(1.0, 1), order.time_in_force, UNIX_EPOCH,
GUID(uuid.uuid4()), UNIX_EPOCH, order.expire_time)
# Act
order.apply(event)
# Assert
# print(order)
self.assertEqual(OrderState.WORKING, order.state)
self.assertEqual(OrderIdBroker('SOME_BROKER_ID'), order.id_broker)
self.assertFalse(order.is_completed)
self.assertTrue(order.is_working)
self.assertEqual(None, order.filled_timestamp)
def test_multiple_strategy_positions_one_active_one_closed(self):
# Arrange
strategy1 = TradingStrategy(order_id_tag='001')
strategy2 = TradingStrategy(order_id_tag='002')
position_id1 = strategy1.position_id_generator.generate()
position_id2 = strategy2.position_id_generator.generate()
self.exec_engine.register_strategy(strategy1)
self.exec_engine.register_strategy(strategy2)
order1 = strategy1.order_factory.stop(AUDUSD_FXCM, OrderSide.BUY,
Quantity(100000),
Price(1.00000, 5))
order2 = strategy1.order_factory.stop(AUDUSD_FXCM, OrderSide.SELL,
Quantity(100000),
Price(1.00000, 5))
order3 = strategy2.order_factory.stop(AUDUSD_FXCM, OrderSide.BUY,
Quantity(100000),
Price(1.00000, 5))
submit_order1 = SubmitOrder(self.trader_id, self.account_id,
strategy1.id, position_id1, order1,
self.guid_factory.generate(),
self.clock.time_now())
submit_order2 = SubmitOrder(self.trader_id, self.account_id,
strategy1.id, position_id1, order2,
self.guid_factory.generate(),
self.clock.time_now())
submit_order3 = SubmitOrder(self.trader_id, self.account_id,
strategy2.id, position_id2, order3,
self.guid_factory.generate(),
self.clock.time_now())
order1_filled = TestStubs.event_order_filled(order1)
order2_filled = TestStubs.event_order_filled(order2)
order3_filled = OrderFilled(self.account_id, order3.id,
ExecutionId('E3'), PositionIdBroker('T3'),
AUDUSD_FXCM,
OrderSide.BUY, Quantity(100000),
Price(1.00000,
5), Currency.USD, UNIX_EPOCH,
GUID(uuid.uuid4()), UNIX_EPOCH)
# Act
self.exec_engine.execute_command(submit_order1)
self.exec_engine.execute_command(submit_order2)
self.exec_engine.execute_command(submit_order3)
self.exec_engine.handle_event(order1_filled)
self.exec_engine.handle_event(order2_filled)
self.exec_engine.handle_event(order3_filled)
# Assert
# Already tested .is_position_active and .is_position_closed above
self.assertTrue(self.exec_db.position_exists(position_id1))
self.assertTrue(self.exec_db.position_exists(position_id2))
self.assertTrue(self.exec_engine.is_strategy_flat(strategy1.id))
self.assertFalse(self.exec_engine.is_strategy_flat(strategy2.id))
self.assertFalse(self.exec_engine.is_flat())
self.assertTrue(
position_id1 in self.exec_db.get_positions(strategy1.id))
self.assertTrue(
position_id2 in self.exec_db.get_positions(strategy2.id))
self.assertTrue(position_id1 in self.exec_db.get_positions())
self.assertTrue(position_id2 in self.exec_db.get_positions())
self.assertEqual(0, len(self.exec_db.get_positions_open(strategy1.id)))
self.assertEqual(1, len(self.exec_db.get_positions_open(strategy2.id)))
self.assertEqual(1, len(self.exec_db.get_positions_open()))
self.assertEqual(1, len(self.exec_db.get_positions_closed()))
self.assertEqual(2, len(self.exec_db.get_positions()))
self.assertTrue(
position_id1 not in self.exec_db.get_positions_open(strategy1.id))
self.assertTrue(
position_id2 in self.exec_db.get_positions_open(strategy2.id))
self.assertTrue(position_id1 not in self.exec_db.get_positions_open())
self.assertTrue(position_id2 in self.exec_db.get_positions_open())
self.assertTrue(
position_id1 in self.exec_db.get_positions_closed(strategy1.id))
self.assertTrue(position_id2 not in self.exec_db.get_positions_closed(
strategy2.id))
self.assertTrue(position_id1 in self.exec_db.get_positions_closed())
self.assertTrue(
position_id2 not in self.exec_db.get_positions_closed())
self.assertEqual(2, self.exec_db.count_positions_total())
self.assertEqual(1, self.exec_db.count_positions_open())
self.assertEqual(1, self.exec_db.count_positions_closed())
def test_position_long_with_multiple_filled_orders_returns_expected_attributes(self):
# Arrange
order1 = self.order_factory.market(
AUDUSD_FXCM,
OrderSide.BUY,
Quantity(100000))
order2 = self.order_factory.market(
AUDUSD_FXCM,
OrderSide.BUY,
Quantity(100000))
order3 = self.order_factory.market(
AUDUSD_FXCM,
OrderSide.SELL,
Quantity(200000))
order1_filled = OrderFilled(
self.account_id,
order1.id,
ExecutionId('E1'),
PositionIdBroker('T123456'),
order1.symbol,
order1.side,
order1.quantity,
Price(1.00000, 5),
Currency.USD,
UNIX_EPOCH,
GUID(uuid.uuid4()),
UNIX_EPOCH)
order2_filled = OrderFilled(
self.account_id,
order2.id,
ExecutionId('E2'),
PositionIdBroker('T123456'),
order2.symbol,
order2.side,
order2.quantity,
Price(1.00001, 5),
Currency.USD,
UNIX_EPOCH,
GUID(uuid.uuid4()),
UNIX_EPOCH)
order3_filled = OrderFilled(
self.account_id,
order3.id,
ExecutionId('E3'),
PositionIdBroker('T123456'),
order3.symbol,
order3.side,
order3.quantity,
Price(1.00010, 5),
Currency.USD,
UNIX_EPOCH,
GUID(uuid.uuid4()),
UNIX_EPOCH)
last = Tick(AUDUSD_FXCM,
Price(1.00050, 5),
Price(1.00048, 5),
Volume(1),
Volume(1),
UNIX_EPOCH)
# Act
position = Position(PositionId('P-123456'), order1_filled)
position.apply(order2_filled)
position.apply(order3_filled)
# Assert
self.assertEqual(Quantity(), position.quantity)
self.assertEqual(MarketPosition.FLAT, position.market_position)
self.assertEqual(UNIX_EPOCH, position.opened_time)
self.assertEqual(1.000005, position.average_open_price)
self.assertEqual(3, position.event_count)
self.assertEqual([order1.id, order2.id, order3.id], position.get_order_ids())
self.assertEqual(ExecutionId('E3'), position.last_execution_id)
self.assertEqual(PositionIdBroker('T123456'), position.id_broker)
self.assertEqual(UNIX_EPOCH, position.closed_time)
self.assertEqual(1.0001, position.average_close_price)
self.assertFalse(position.is_long)
self.assertFalse(position.is_short)
self.assertTrue(position.is_closed)
self.assertEqual(9.499999999995623e-05, position.realized_points)
self.assertEqual(9.499952500233122e-05, position.realized_return)
self.assertEqual(Money(19.000, Currency.USD), position.realized_pnl)
self.assertEqual(0.0, position.unrealized_points(last))
self.assertEqual(0.0, position.unrealized_return(last))
self.assertEqual(Money(00, Currency.USD), position.unrealized_pnl(last))
self.assertEqual(9.499999999995623e-05, position.total_points(last))
self.assertEqual(9.499952500233122e-05, position.total_return(last))
self.assertEqual(Money(19.000, Currency.USD), position.total_pnl(last))
def test_position_filled_with_sell_order_then_buy_order_returns_expected_attributes(self):
# Arrange
order1 = self.order_factory.market(
AUDUSD_FXCM,
OrderSide.SELL,
Quantity(100000))
order2 = self.order_factory.market(
AUDUSD_FXCM,
OrderSide.BUY,
Quantity(100000))
order_filled1 = OrderFilled(
self.account_id,
order1.id,
ExecutionId('E123456'),
PositionIdBroker('T123456'),
order1.symbol,
order1.side,
order1.quantity,
Price(1.00000, 5),
Currency.USD,
UNIX_EPOCH,
GUID(uuid.uuid4()),
UNIX_EPOCH)
position = Position(PositionId('P-123456'), order_filled1)
order_filled2 = OrderPartiallyFilled(
self.account_id,
order2.id,
ExecutionId('E1234561'),
PositionIdBroker('T123456'),
order2.symbol,
order2.side,
Quantity(50000),
Quantity(50000),
Price(1.00001, 5),
Currency.USD,
UNIX_EPOCH,
GUID(uuid.uuid4()),
UNIX_EPOCH)
order_filled3 = OrderPartiallyFilled(
self.account_id,
order2.id,
ExecutionId('E1234562'),
PositionIdBroker('T123456'),
order2.symbol,
order2.side,
Quantity(100000),
Quantity(),
Price(1.00003, 5),
Currency.USD,
UNIX_EPOCH,
GUID(uuid.uuid4()),
UNIX_EPOCH)
last = Tick(AUDUSD_FXCM,
Price(1.00050, 5),
Price(1.00048, 5),
Volume(1),
Volume(1),
UNIX_EPOCH)
# Act
position.apply(order_filled2)
position.apply(order_filled3)
# Assert
self.assertEqual(Quantity(), position.quantity)
self.assertEqual(MarketPosition.FLAT, position.market_position)
self.assertEqual(UNIX_EPOCH, position.opened_time)
self.assertEqual(1.0, position.average_open_price)
self.assertEqual(3, position.event_count)
self.assertEqual([order1.id, order2.id], position.get_order_ids())
self.assertEqual(ExecutionId('E1234562'), position.last_execution_id)
self.assertEqual(PositionIdBroker('T123456'), position.id_broker)
self.assertEqual(UNIX_EPOCH, position.closed_time)
self.assertEqual(1.00003, position.average_close_price)
self.assertFalse(position.is_long)
self.assertFalse(position.is_short)
self.assertTrue(position.is_closed)
self.assertEqual(-2.999999999997449e-05, position.realized_points)
self.assertEqual(-2.999999999997449e-05, position.realized_return)
self.assertEqual(Money(-3.000, Currency.USD), position.realized_pnl)
self.assertEqual(0.0, position.unrealized_points(last))
self.assertEqual(0.0, position.unrealized_return(last))
self.assertEqual(Money(00, Currency.USD), position.unrealized_pnl(last))
self.assertEqual(-2.999999999997449e-05, position.total_points(last))
self.assertEqual(-2.999999999997449e-05, position.total_return(last))
self.assertEqual(Money(-3.000, Currency.USD), position.total_pnl(last))
def test_position_filled_with_buy_order_then_sell_order_returns_expected_attributes(self):
# Arrange
order = self.order_factory.market(
AUDUSD_FXCM,
OrderSide.BUY,
Quantity(100000))
order_filled1 = OrderFilled(
self.account_id,
order.id,
ExecutionId('E1'),
PositionIdBroker('T123456'),
order.symbol,
OrderSide.BUY,
order.quantity,
Price(1.00001, 5),
Currency.USD,
UNIX_EPOCH,
GUID(uuid.uuid4()),
UNIX_EPOCH)
position = Position(PositionId('P-123456'), order_filled1)
order_filled2 = OrderFilled(
self.account_id,
order.id,
ExecutionId('E2'),
PositionIdBroker('T123456'),
order.symbol,
OrderSide.SELL,
order.quantity,
Price(1.00001, 5),
Currency.USD,
UNIX_EPOCH + timedelta(minutes=1),
GUID(uuid.uuid4()),
UNIX_EPOCH)
last = Tick(AUDUSD_FXCM,
Price(1.00050, 5),
Price(1.00048, 5),
Volume(1),
Volume(1),
UNIX_EPOCH)
# Act
position.apply(order_filled2)
# Assert
self.assertEqual(Quantity(), position.quantity)
self.assertEqual(MarketPosition.FLAT, position.market_position)
self.assertEqual(UNIX_EPOCH, position.opened_time)
self.assertEqual(timedelta(minutes=1), position.open_duration)
self.assertEqual(1.00001, position.average_open_price)
self.assertEqual(2, position.event_count)
self.assertEqual(ExecutionId('E2'), position.last_execution_id)
self.assertEqual(PositionIdBroker('T123456'), position.id_broker)
self.assertEqual(datetime.datetime(1970, 1, 1, 0, 1, tzinfo=datetime.timezone.utc), position.closed_time)
self.assertEqual(1.00001, position.average_close_price)
self.assertFalse(position.is_long)
self.assertFalse(position.is_short)
self.assertTrue(position.is_closed)
self.assertEqual(0.0, position.realized_points)
self.assertEqual(0.0, position.realized_return)
self.assertEqual(Money(0, Currency.USD), position.realized_pnl)
self.assertEqual(0.0, position.unrealized_points(last))
self.assertEqual(0.0, position.unrealized_return(last))
self.assertEqual(Money(0, Currency.USD), position.unrealized_pnl(last))
self.assertEqual(0.0, position.total_points(last))
self.assertEqual(0.0, position.total_return(last))
self.assertEqual(Money(0, Currency.USD), position.total_pnl(last))
def test_market_order_with_quantity_zero_raises_exception(self):
# Arrange
# Act
self.assertRaises(ValueError, Order, OrderId('O-123456'), AUDUSD_FXCM,
OrderSide.BUY, OrderType.MARKET, Quantity(),
GUID(uuid.uuid4()), UNIX_EPOCH)
import unittest
import uuid
from nautilus_trader.core.types import GUID
from nautilus_trader.core.message import Message, MessageType
from nautilus_trader.core.functions import fast_mean
from nautilus_trader.model.identifiers import Symbol, Venue
from nautilus_trader.model.commands import SubmitOrder
from tests.test_kit.performance import PerformanceHarness
from tests.test_kit.stubs import UNIX_EPOCH
_AUDUSD = Symbol('AUDUSD', Venue('IDEALPRO'))
_TEST_LIST = [0.0, 1.1, 2.2, 3.3, 4.4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
_MESSAGE = Message(MessageType.COMMAND, GUID(uuid.uuid4()), UNIX_EPOCH)
class Experiments:
@staticmethod
def built_in_arithmetic():
x = 1 + 1
@staticmethod
def class_name():
x = '123'.__class__.__name__
@staticmethod
def str_assignment():
x = '123'
def test_none_returns_empty_guid(self):
# Arrange
value = GUID.py_none()
# Act
self.assertEqual('00000000-0000-0000-0000-000000000000', value.value)
