def test_equality_with_various_values_returns_expected_result(self, value1, value2, expected):
# Arrange
# Act
result = Decimal(value1) == Decimal(value2)
# Assert
self.assertEqual(expected, result)
def test_str_and_as_string_with_various_values_returns_expected_string(self, value, expected):
# Arrange
# Act
quantity = Decimal(value)
# Assert
self.assertEqual(expected, str(quantity))
self.assertEqual(expected, quantity.to_string())
def test_str_and_as_string_with_various_values_returns_expected_string(
self, value, expected):
# Arrange
# Act
decimal_object = Decimal(value)
# Assert
self.assertEqual(expected, str(decimal_object))
self.assertEqual(expected, decimal_object.to_string())
def test_initialized_with_extreme_value_scientific_notation_returns_zero(self):
# Arrange
# Act
result1 = Decimal.from_float(1E-10, 9) # Max precision
result2 = Decimal.from_float(-1E-10, 9) # Max precision
# Assert
self.assertEqual(0.0, result1.as_double())
self.assertEqual(0.0, result2.as_double())
def test_initialized_with_no_value_returns_valid_decimal(self):
# Arrange
# Act
result = Decimal()
# Assert
self.assertEqual(0, result)
self.assertEqual(0, result.precision)
# self.assertEqual(decimal.Decimal("0"), result.as_decimal())
self.assertEqual(0, result.as_double())
def test_instantiate_with_valid_inputs_returns_expected_values(self):
# Arrange
# Act
result0 = Decimal.from_float(1.0, 1)
result1 = Decimal.from_float(1.0, 2)
result2 = Decimal.from_float(-1.001, 3)
result3 = Decimal.from_float(1.0005, 3)
result4 = Decimal(100)
result5 = Decimal.from_float(10000000000001.01, 2) # Max significands
result6 = Decimal.from_float(1999999.000001015, 9) # Max significands and precision
# Assert # TODO: Keep as_decimal?
# self.assertEqual(decimal.Decimal("1"), result0.as_decimal())
# self.assertEqual(decimal.Decimal("1.00"), result1.as_decimal())
# self.assertEqual(decimal.Decimal("-1.001"), result2.as_decimal())
# self.assertEqual(decimal.Decimal("1.000"), result3.as_decimal()) # Rounds down
# self.assertEqual(decimal.Decimal("100.0"), result4.as_decimal())
# self.assertEqual(decimal.Decimal("10000000000001.01"), result5.as_decimal())
# self.assertEqual(decimal.Decimal("1999999.000001015"), result6.as_decimal())
self.assertEqual(1, result0)
self.assertEqual(1, result0)
self.assertEqual(Decimal.from_float(-1.001, precision=3), result2)
self.assertEqual(Decimal.from_float(1.000, precision=3), result3)
self.assertEqual(100, result4)
self.assertEqual(10000000000001.01, result5.as_double())
self.assertEqual(1999999.000001015, result6.as_double())
self.assertEqual("1.0", result0.to_string())
self.assertEqual("1.00", result1.to_string())
self.assertEqual("-1.001", result2.to_string())
self.assertEqual("1.000", result3.to_string())
self.assertEqual("10000000000001.01", result5.to_string())
self.assertEqual("1999999.000001015", result6.to_string())
def test_as_double_with_various_values_returns_expected_double(self):
# Arrange
# Act
result0 = Decimal.from_float(1.0012, 0).as_double()
result1 = Decimal.from_float(1.0012, 3).as_double()
result2 = Decimal.from_float(-0.020, 2).as_double()
result3 = Decimal.from_float(1.0015, 3).as_double()
# Assert
self.assertEqual(1.0, result0)
self.assertEqual(1.001, result1)
self.assertEqual(-0.02, result2)
self.assertEqual(1.002, result3)
def test_as_double_with_various_values_returns_expected_value(self, value, expected):
# Arrange
# Act
result = Decimal(value).as_double()
# Assert
self.assertEqual(expected, result)
def test_from_float_with_various_valid_inputs_returns_expected_decimal(self, value, precision, expected):
# Arrange
# Act
quantity = Decimal.from_float(value, precision)
# Assert
self.assertEqual(expected, quantity)
def test_instantiate_with_various_valid_inputs_returns_expected_decimal(self, value, expected):
# Arrange
# Act
quantity = Decimal(value)
# Assert
self.assertEqual(expected, quantity)
def test_repr(self):
# Arrange
# Act
result = repr(Decimal("1.1"))
# Assert
self.assertTrue(result.startswith("<Decimal('1.1') object at "))
self.assertTrue(result.endswith(">"))
def test_default_fx_with_3_dp_returns_expected_instrument(self):
# Arrange
loader = InstrumentLoader()
# Act
instrument = loader.default_fx_ccy(Symbol("USD/JPY", Venue('FXCM')))
# Assert
self.assertEqual(Symbol("USD/JPY", Venue('FXCM')), instrument.symbol)
self.assertEqual(3, instrument.price_precision)
self.assertEqual(Decimal("0.001"), instrument.tick_size)
self.assertEqual(
Currency(code='JPY', precision=2, currency_type=CurrencyType.FIAT),
instrument.quote_currency)
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"),
)
order1.apply(TestStubs.event_order_submitted(order1))
order1.apply(TestStubs.event_order_accepted(order1))
order1.apply(TestStubs.event_order_working(order1))
order2 = self.order_factory.limit(
AUDUSD_FXCM,
OrderSide.SELL,
Quantity(1500000),
Price("0.80000"),
)
submitted2 = TestStubs.event_order_submitted(order2)
accepted2 = TestStubs.event_order_accepted(order2)
working2 = TestStubs.event_order_working(order2)
order2.apply(submitted2)
order2.apply(accepted2)
order2.apply(working2)
filled = TestStubs.event_order_filled(order1, PositionId("P-1"), StrategyId("S", "1"), Price("0.80011"))
order1.apply(filled)
orders = [order1, order2]
# Act
report = report_provider.generate_order_fills_report(orders)
# Assert
self.assertEqual(1, len(report))
self.assertEqual("cl_ord_id", report.index.name)
self.assertEqual(order1.cl_ord_id.value, report.index[0])
self.assertEqual("AUD/USD", 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.assertEqual(Decimal("0.80011"), report.iloc[0]["avg_price"])
self.assertEqual(0.00001, report.iloc[0]["slippage"])
def test_can_apply_order_filled_event_to_buy_limit_order(self):
# Arrange
order = self.order_factory.limit(
AUDUSD_FXCM,
OrderSide.BUY,
Quantity(100000),
Price("1.00000"))
submitted = TestStubs.event_order_submitted(order)
accepted = TestStubs.event_order_accepted(order)
working = TestStubs.event_order_working(order)
filled = OrderFilled(
self.account_id,
order.cl_ord_id,
OrderId("1"),
ExecutionId("E-1"),
PositionId("P-1"),
StrategyId("S", "NULL"),
order.symbol,
order.side,
order.quantity,
Quantity(),
Price("1.00001"),
Money(0, USD),
LiquiditySide.MAKER,
USD,
USD,
UNIX_EPOCH,
uuid4(),
UNIX_EPOCH,
)
order.apply(submitted)
order.apply(accepted)
order.apply(working)
# Act
order.apply(filled)
# Assert
self.assertEqual(OrderState.FILLED, order.state())
self.assertEqual(Quantity(100000), order.filled_qty)
self.assertEqual(Price("1.00000"), order.price)
self.assertEqual(Price("1.00001"), order.avg_price)
self.assertEqual(Decimal("0.00001"), order.slippage)
self.assertTrue(order.is_completed())
self.assertEqual(UNIX_EPOCH, order.filled_timestamp)
def test_comparisons_with_various_values_returns_expected_result(
self,
value1,
value2,
expected1,
expected2,
expected3,
expected4,
):
# Arrange
# Act
result1 = Decimal(value1) > Decimal(value2)
result2 = Decimal(value1) >= Decimal(value2)
result3 = Decimal(value1) <= Decimal(value2)
result4 = Decimal(value1) < Decimal(value2)
# Assert
self.assertEqual(expected1, result1)
self.assertEqual(expected2, result2)
self.assertEqual(expected3, result3)
self.assertEqual(expected4, result4)
def test_comparisons_with_various_values_returns_expected_result(self):
# Arrange
# Act
# Assert
self.assertTrue(Decimal.from_float(0.000000001, 9) > Decimal.from_float(0, 9))
self.assertTrue(Decimal.from_float(0.000000001, 9) >= Decimal.from_float(0, 9))
self.assertTrue(Decimal() >= Decimal(0))
self.assertTrue(Decimal.from_float(1.0, 1) >= Decimal.from_float(1.0, 0))
self.assertTrue(Decimal.from_float(0.000000000, 9) < Decimal.from_float(0.000000001, 9))
self.assertTrue(Decimal.from_float(0.000000001, 9) <= Decimal.from_float(0.000000001, 9))
self.assertTrue(Decimal() <= Decimal(0))
self.assertTrue(Decimal.from_float(1.0, 0) <= Decimal.from_float(1.0, 0))
# See the License for the specific language governing permissions and
# limitations under the License.
# -------------------------------------------------------------------------------------------------
import decimal
import unittest
from nautilus_trader.model.objects import Decimal
from nautilus_trader.model.objects import Price
from tests.test_kit.performance import PerformanceHarness
_PRECISION_5_CONTEXT = decimal.Context(prec=5)
_BUILTIN_DECIMAL1 = decimal.Decimal("1.00000")
_BUILTIN_DECIMAL2 = decimal.Decimal("1.00001")
_DECIMAL1 = Decimal("1.00000")
_DECIMAL2 = Decimal("1.00001")
class DecimalTesting:
@staticmethod
def make_builtin_decimal():
decimal.Decimal("1.23456")
@staticmethod
def make_decimal():
Decimal("1.23456")
@staticmethod
def float_comparisons():
1.0 == 2.0 # noqa
def make_decimal():
Decimal("1.23456")
class DecimalTests(unittest.TestCase):
def test_instantiate_with_none_value_raises_type_error(self):
# Arrange
# Act
# Assert
self.assertRaises(TypeError, Decimal, None)
def test_instantiate_with_float_value_raises_type_error(
self): # User should use .from_float()
# Arrange
# Act
# Assert
self.assertRaises(TypeError, Decimal, 1.1)
def test_from_float_with_negative_precision_argument_returns_zero_decimal(
self):
# Arrange
# Act
# Assert
self.assertRaises(ValueError, Decimal.from_float, 1.11, -1)
@parameterized.expand([
[0, Decimal()],
[1, Decimal("1")],
[-1, Decimal("-1")],
["0", Decimal()],
["0.0", Decimal()],
["-0.0", Decimal()],
["1.0", Decimal("1")],
["-1.0", Decimal("-1")],
[decimal.Decimal(), Decimal()],
[decimal.Decimal("1.1"), Decimal("1.1")],
[decimal.Decimal("-1.1"), Decimal("-1.1")],
[Fraction(), Decimal()],
[Fraction("1.1"), Decimal("1.1")],
[Fraction("-1.1"), Decimal("-1.1")],
])
def test_instantiate_with_various_valid_inputs_returns_expected_decimal(
self, value, expected):
# Arrange
# Act
decimal_object = Decimal(value)
# Assert
self.assertEqual(expected, decimal_object)
@parameterized.expand([
[0., 0, Decimal("0")],
[1., 0, Decimal("1")],
[-1., 0, Decimal("-1")],
[1.123, 3, Decimal("1.123")],
[-1.123, 3, Decimal("-1.123")],
[1.155, 2, Decimal("1.16")],
])
def test_from_float_with_various_valid_inputs_returns_expected_decimal(
self, value, precision, expected):
# Arrange
# Act
decimal_object = Decimal.from_float(value, precision)
# Assert
self.assertEqual(expected, decimal_object)
@parameterized.expand([
["0", 0],
["-0", 0],
["-1", -1],
["1", 1],
["1.1", 1.1],
["-1.1", -1.1],
])
def test_as_double_with_various_values_returns_expected_value(
self, value, expected):
# Arrange
# Act
result = Decimal(value).as_double()
# Assert
self.assertEqual(expected, result)
@parameterized.expand([
["0", -0, True],
["-0", 0, True],
["-1", -1, True],
["1", 1, True],
["1.1", "1.1", True],
["-1.1", "-1.1", True],
["0", 1, False],
["-1", 0, False],
["-1", -2, False],
["1", 2, False],
["1.1", "1.12", False],
["-1.12", "-1.1", False],
])
def test_equality_with_various_values_returns_expected_result(
self, value1, value2, expected):
# Arrange
# Act
result = Decimal(value1) == Decimal(value2)
# Assert
self.assertEqual(expected, result)
@parameterized.expand([
[0, 0, False, True, True, False],
[1, 0, True, True, False, False],
[-1, 0, False, False, True, True],
])
def test_comparisons_with_various_values_returns_expected_result(
self,
value1,
value2,
expected1,
expected2,
expected3,
expected4,
):
# Arrange
# Act
result1 = Decimal(value1) > Decimal(value2)
result2 = Decimal(value1) >= Decimal(value2)
result3 = Decimal(value1) <= Decimal(value2)
result4 = Decimal(value1) < Decimal(value2)
# Assert
self.assertEqual(expected1, result1)
self.assertEqual(expected2, result2)
self.assertEqual(expected3, result3)
self.assertEqual(expected4, result4)
@parameterized.expand([
[Decimal(), Decimal(), Fraction, 0],
[Decimal(), Decimal("1.1"), Fraction,
Fraction("1.1")],
[Decimal(), 0, Fraction, 0],
[Decimal(), 1, Fraction, 1],
[Decimal(), 0.0, float, 0],
[Decimal(), 1.0, float, 1.0],
[Decimal("1"),
Fraction("1.1"), Fraction,
Fraction("2.1")],
])
def test_addition_with_various_types_returns_expected_result(
self, value1, value2, expected_type, expected_value):
# Arrange
# Act
result = value1 + value2
# Assert
self.assertEqual(expected_type, type(result))
self.assertEqual(expected_value, result)
@parameterized.expand([
[Decimal(), Decimal(), Fraction, 0],
[Decimal(), Decimal("1.1"), Fraction,
Fraction("-1.1")],
[Decimal(), 0, Fraction, 0],
[Decimal(), 1, Fraction, -1],
[Decimal(), 0.0, float, 0],
[Decimal(), 1.0, float, -1.0],
[Decimal("1"),
Fraction("1.1"), Fraction,
Fraction("-0.1")],
])
def test_subtraction_with_various_types_returns_expected_result(
self, value1, value2, expected_type, expected_value):
# Arrange
# Act
result = value1 - value2
# Assert
self.assertEqual(expected_type, type(result))
self.assertEqual(expected_value, result)
@parameterized.expand([
[Decimal(), 0, Fraction, 0],
[Decimal(1), 1, Fraction, 1],
[Decimal(2), 1.0, float, 2],
[Decimal("1.1"),
Fraction("1.1"), Fraction,
Fraction("1.21")],
])
def test_multiplication_with_various_types_returns_expected_result(
self, value1, value2, expected_type, expected_value):
# Arrange
# Act
result = value1 * value2
# Assert
self.assertEqual(expected_type, type(result))
self.assertEqual(expected_value, result)
@parameterized.expand([
[Decimal(), 1, Fraction, 0],
[Decimal(1), 2, Fraction, 0.5],
[Decimal(2), 1.0, float, 2],
[Decimal("1.1"),
Fraction("1.2"), Fraction, 0.9166666666666666],
])
def test_division_with_various_types_returns_expected_result(
self, value1, value2, expected_type, expected_value):
# Arrange
# Act
result = value1 / value2
# Assert
self.assertEqual(expected_type, type(result))
self.assertAlmostEqual(expected_value, result)
@parameterized.expand([
["0", "0"],
["-0", "0"],
["-1", "-1"],
["1", "1"],
["1.1", "1.1"],
["-1.1", "-1.1"],
])
def test_str_and_as_string_with_various_values_returns_expected_string(
self, value, expected):
# Arrange
# Act
decimal_object = Decimal(value)
# Assert
self.assertEqual(expected, str(decimal_object))
self.assertEqual(expected, decimal_object.to_string())
def test_repr(self):
# Arrange
# Act
result = repr(Decimal("1.1"))
# Assert
self.assertTrue(result.startswith("<Decimal('1.1') object at "))
self.assertTrue(result.endswith(">"))
def test_equality_with_various_values_returns_expected_result(self):
# Arrange
# Act
# Assert
self.assertEqual(Decimal(), Decimal(0))
self.assertEqual(Decimal.from_float(1.0, 1), Decimal.from_float(1.0, 1))
self.assertEqual(Decimal.from_float(1000000000000001, 9), Decimal.from_float(1000000000000001, 9))
self.assertEqual(Decimal.from_float(10000000000001.01, 9), Decimal.from_float(10000000000001.01, 9))
self.assertEqual(Decimal.from_float(1999999.000001015, 9), Decimal.from_float(1999999.000001015, 9))
self.assertNotEqual(Decimal.from_float(1999999.000001015, 9), Decimal.from_float(1999999.000001014, 9))