コード例 #1
0
    def test_order_identifier(self):
        # Arrange
        # Act
        order_id = OrderId.null()

        # Assert
        self.assertEqual("NULL", order_id.value)
コード例 #2
0
    def test_add_order(self):
        # Arrange
        order = self.strategy.order_factory.market(
            AUDUSD_SIM.symbol,
            OrderSide.BUY,
            Quantity(100000),
        )

        position_id = PositionId('P-1')

        # Act
        self.cache.add_order(order, position_id)

        # Assert
        self.assertIn(order.cl_ord_id, self.cache.order_ids())
        self.assertIn(order.cl_ord_id,
                      self.cache.order_ids(symbol=order.symbol))
        self.assertIn(order.cl_ord_id,
                      self.cache.order_ids(strategy_id=self.strategy.id))
        self.assertNotIn(
            order.cl_ord_id,
            self.cache.order_ids(strategy_id=StrategyId("S", "ZX1")))
        self.assertIn(
            order.cl_ord_id,
            self.cache.order_ids(symbol=order.symbol,
                                 strategy_id=self.strategy.id))
        self.assertIn(order, self.cache.orders())
        self.assertEqual(OrderId.null(), self.cache.order_id(order.cl_ord_id))
        self.assertIsNone(self.cache.cl_ord_id(order.id))
コード例 #3
0
    def test_order_identifier(self):
        # Arrange
        # Act
        order_id = OrderId.null()

        # Assert
        assert "NULL" == order_id.value
コード例 #4
0
    def test_position_filled_with_buy_order_returns_expected_attributes(self):
        # Arrange
        order = self.order_factory.market(
            AUDUSD_SIM.symbol,
            OrderSide.BUY,
            Quantity(100000),
        )

        fill = TestStubs.event_order_filled(
            order,
            instrument=AUDUSD_SIM,
            position_id=PositionId("P-123456"),
            strategy_id=StrategyId("S", "001"),
            fill_price=Price("1.00001"),
        )

        last = Price("1.00050")

        # Act
        position = Position(fill)

        # Assert
        self.assertFalse(position != position)  # Equality operator test
        self.assertEqual(ClientOrderId("O-19700101-000000-000-001-1"),
                         position.from_order)
        self.assertEqual(Quantity(100000), position.quantity)
        self.assertEqual(Quantity(100000), position.peak_quantity)
        self.assertEqual(OrderSide.BUY, position.entry)
        self.assertEqual(PositionSide.LONG, position.side)
        self.assertEqual(UNIX_EPOCH, position.opened_time)
        self.assertIsNone(position.open_duration)
        self.assertEqual(Decimal("1.00001"), position.avg_open)
        self.assertEqual(1, position.event_count)
        self.assertEqual([order.cl_ord_id], position.cl_ord_ids)
        self.assertEqual([OrderId.null()], position.order_ids)
        self.assertEqual([ExecutionId("E-19700101-000000-000-001-1")],
                         position.execution_ids)
        self.assertEqual(ExecutionId("E-19700101-000000-000-001-1"),
                         position.last_execution_id)
        self.assertEqual(PositionId("P-123456"), position.id)
        self.assertEqual(1, len(position.events))
        self.assertTrue(position.is_long)
        self.assertFalse(position.is_short)
        self.assertTrue(position.is_open)
        self.assertFalse(position.is_closed)
        self.assertEqual(0, position.realized_points)
        self.assertEqual(0, position.realized_return)
        self.assertEqual(Money(-2.00, USD), position.realized_pnl)
        self.assertEqual(Money(49.00, USD), position.unrealized_pnl(last))
        self.assertEqual(Money(47.00, USD), position.total_pnl(last))
        self.assertEqual(Money(2.00, USD), position.commission)
        self.assertEqual([Money(2.00, USD)], position.commissions())
        self.assertEqual("Position(id=P-123456, LONG 100,000 AUD/USD.SIM)",
                         repr(position))