def test_activation_price_success(self):
self.order_builder.set_activation_price(54.03)
self.assertFalse(
has_diff({'activationPrice': 54.03}, self.order_builder.build()))
self.order_builder.clear_activation_price()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_price_link_type_success(self):
self.order_builder.set_price_link_type(PriceLinkType.PERCENT)
self.assertFalse(
has_diff({'priceLinkType': 'PERCENT'}, self.order_builder.build()))
self.order_builder.clear_price_link_type()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_price_success(self):
self.order_builder.set_price(23.49)
self.assertFalse(
has_diff({'price': '23.49'}, self.order_builder.build()))
self.order_builder.clear_price()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_stop_type_success(self):
self.order_builder.set_stop_type(StopType.MARK)
self.assertFalse(
has_diff({'stopType': 'MARK'}, self.order_builder.build()))
self.order_builder.clear_stop_type()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_stop_price_offset_success(self):
self.order_builder.set_stop_price_offset(12.98)
self.assertFalse(
has_diff({'stopPriceOffset': 12.98}, self.order_builder.build()))
self.order_builder.clear_stop_price_offset()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_stop_price_success(self):
self.order_builder.set_stop_price(42.90)
self.assertFalse(
has_diff({'stopPrice': '42.90'}, self.order_builder.build()))
self.order_builder.clear_stop_price()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_duration_success(self):
self.order_builder.set_duration(Duration.DAY)
self.assertFalse(
has_diff({'duration': 'DAY'}, self.order_builder.build()))
self.order_builder.clear_duration()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_order_strategy_type_success(self):
self.order_builder.set_order_strategy_type(OrderStrategyType.OCO)
self.assertFalse(
has_diff({'orderStrategyType': 'OCO'}, self.order_builder.build()))
self.order_builder.clear_order_strategy_type()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_quantity_success(self):
self.order_builder.set_quantity(12)
self.assertFalse(has_diff({'quantity': 12},
self.order_builder.build()))
self.order_builder.clear_quantity()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_add_option_leg_success(self):
self.order_builder.add_option_leg(
OptionInstruction.BUY_TO_OPEN, 'GOOG31433C1342', 10)
self.order_builder.add_option_leg(
OptionInstruction.BUY_TO_CLOSE, 'MSFT439132P35', 1)
self.assertFalse(has_diff({
'orderLegCollection': [{
'instruction': 'BUY_TO_OPEN',
'instrument': {
'symbol': 'GOOG31433C1342',
'assetType': 'OPTION'
},
'quantity': 10,
}, {
'instruction': 'BUY_TO_CLOSE',
'instrument': {
'symbol': 'MSFT439132P35',
'assetType': 'OPTION'
},
'quantity': 1,
}]
}, self.order_builder.build()))
self.order_builder.clear_order_legs()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_session_success(self):
self.order_builder.set_session(Session.NORMAL)
self.assertFalse(
has_diff({'session': 'NORMAL'}, self.order_builder.build()))
self.order_builder.clear_session()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_order_type_success(self):
self.order_builder.set_order_type(OrderType.MARKET)
self.assertFalse(
has_diff({'orderType': 'MARKET'}, self.order_builder.build()))
self.order_builder.clear_order_type()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_add_option_leg_wrong_type_no_check(self):
self.order_builder = OrderBuilder(enforce_enums=False)
self.order_builder.add_option_leg('BUY_TO_OPEN', 'GOOG31433C1342', 10)
self.order_builder.add_option_leg('BUY_TO_CLOSE', 'MSFT439132P35', 1)
self.assertFalse(has_diff({
'orderLegCollection': [{
'instruction': 'BUY_TO_OPEN',
'instrument': {
'symbol': 'GOOG31433C1342',
'assetType': 'OPTION'
},
'quantity': 10,
}, {
'instruction': 'BUY_TO_CLOSE',
'instrument': {
'symbol': 'MSFT439132P35',
'assetType': 'OPTION'
},
'quantity': 1,
}]
}, self.order_builder.build()))
self.order_builder.clear_order_legs()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_add_equity_leg_success(self):
self.order_builder.add_equity_leg(EquityInstruction.BUY, 'GOOG', 10)
self.order_builder.add_equity_leg(EquityInstruction.SELL_SHORT, 'MSFT',
1)
self.assertFalse(
has_diff(
{
'orderLegCollection': [{
'instruction': 'BUY',
'instrument': {
'symbol': 'GOOG',
'assetType': 'EQUITY'
},
'quantity': 10,
}, {
'instruction': 'SELL_SHORT',
'instrument': {
'symbol': 'MSFT',
'assetType': 'EQUITY'
},
'quantity': 1,
}]
}, self.order_builder.build()))
self.order_builder.clear_order_legs()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_stop_price_link_basis_success(self):
self.order_builder.set_stop_price_link_basis(StopPriceLinkBasis.ASK)
self.assertFalse(has_diff({
'stopPriceLinkBasis': 'ASK'
}, self.order_builder.build()))
self.order_builder.clear_stop_price_link_basis()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_stop_price_link_type_success(self):
self.order_builder.set_stop_price_link_type(StopPriceLinkType.VALUE)
self.assertFalse(has_diff({
'stopPriceLinkType': 'VALUE'
}, self.order_builder.build()))
self.order_builder.clear_stop_price_link_type()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_price_link_basis_success(self):
self.order_builder.set_price_link_basis(PriceLinkBasis.AVERAGE)
self.assertFalse(has_diff({
'priceLinkBasis': 'AVERAGE'
}, self.order_builder.build()))
self.order_builder.clear_price_link_basis()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_requested_destination_success(self):
self.order_builder.set_requested_destination(Destination.INET)
self.assertFalse(has_diff({
'requestedDestination': 'INET'
}, self.order_builder.build()))
self.order_builder.clear_requested_destination()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_complex_order_strategy_type_success(self):
self.order_builder.set_complex_order_strategy_type(
ComplexOrderStrategyType.IRON_CONDOR)
self.assertFalse(has_diff({
'complexOrderStrategyType': 'IRON_CONDOR'
}, self.order_builder.build()))
self.order_builder.clear_complex_order_strategy_type()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_add_child_order_strategy_success(self):
self.order_builder.add_child_order_strategy(
OrderBuilder().set_session(Session.NORMAL))
self.assertFalse(has_diff({
'childOrderStrategies': [{'session': 'NORMAL'}]
}, self.order_builder.build()))
self.order_builder.clear_child_order_strategies()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_special_instruction_success(self):
self.order_builder.set_special_instruction(
SpecialInstruction.DO_NOT_REDUCE)
self.assertFalse(has_diff({
'specialInstruction': 'DO_NOT_REDUCE'
}, self.order_builder.build()))
self.order_builder.clear_special_instruction()
self.assertFalse(has_diff({}, self.order_builder.build()))
def test_buy_limit_single_option(self):
builder = (
OrderBuilder()
.set_complex_order_strategy_type(ComplexOrderStrategyType.NONE)
.set_order_type(OrderType.LIMIT)
.set_session(Session.NORMAL)
.set_price(6.45)
.set_duration(Duration.DAY)
.set_order_strategy_type(OrderStrategyType.SINGLE)
.add_option_leg(OptionInstruction.BUY_TO_OPEN, 'XYZ_032015C49', 10))
expected = {
'complexOrderStrategyType': 'NONE',
'orderType': 'LIMIT',
'session': 'NORMAL',
'price': '6.45',
'duration': 'DAY',
'orderStrategyType': 'SINGLE',
'orderLegCollection': [
{
'instruction': 'BUY_TO_OPEN',
'quantity': 10,
'instrument': {
'symbol': 'XYZ_032015C49',
'assetType': 'OPTION'
}
}
]
}
self.assertFalse(has_diff(expected, builder.build()))
def test_buy_market_stock(self):
builder = (
OrderBuilder()
.set_order_type(OrderType.MARKET)
.set_session(Session.NORMAL)
.set_duration(Duration.DAY)
.set_order_strategy_type(OrderStrategyType.SINGLE)
.add_equity_leg(EquityInstruction.BUY, 'XYZ', 15))
expected = {
'orderType': 'MARKET',
'session': 'NORMAL',
'duration': 'DAY',
'orderStrategyType': 'SINGLE',
'orderLegCollection': [
{
'instruction': 'BUY', # The original says 'Buy'
'quantity': 15,
'instrument': {
'symbol': 'XYZ',
'assetType': 'EQUITY'
}
}
]
}
self.assertFalse(has_diff(expected, builder.build()))
def test_add_equity_leg_wrong_type_no_check(self):
self.order_builder = OrderBuilder(enforce_enums=False)
self.order_builder.add_equity_leg('BUY', 'GOOG', 10)
self.order_builder.add_equity_leg('SELL_TO_CLOSE', 'MSFT', 1)
self.assertFalse(
has_diff(
{
'orderLegCollection': [{
'instruction': 'BUY',
'instrument': {
'symbol': 'GOOG',
'assetType': 'EQUITY'
},
'quantity': 10,
}, {
'instruction': 'SELL_TO_CLOSE',
'instrument': {
'symbol': 'MSFT',
'assetType': 'EQUITY'
},
'quantity': 1,
}]
}, self.order_builder.build()))
def test_option_sell_to_open_limit(self):
self.assertFalse(
has_diff(
{
'orderType':
'LIMIT',
'session':
'NORMAL',
'duration':
'DAY',
'orderStrategyType':
'SINGLE',
'price':
'32.50',
'orderLegCollection': [{
'instruction': 'SELL_TO_OPEN',
'quantity': 10,
'instrument': {
'symbol': 'GOOG_012122P2200',
'assetType': 'OPTION',
}
}]
},
option_sell_to_open_limit('GOOG_012122P2200', 10,
32.5).build()))
def test_bear_put_vertical_close(self):
self.assertFalse(has_diff({
'orderType': 'NET_CREDIT',
'session': 'NORMAL',
'duration': 'DAY',
'orderStrategyType': 'SINGLE',
'price': '30.60',
'complexOrderStrategyType': 'VERTICAL',
'quantity': 3,
'orderLegCollection': [{
'instruction': 'BUY_TO_CLOSE',
'quantity': 3,
'instrument': {
'symbol': 'GOOG_012122P2200',
'assetType': 'OPTION',
}
}, {
'instruction': 'SELL_TO_CLOSE',
'quantity': 3,
'instrument': {
'symbol': 'GOOG_012122P2400',
'assetType': 'OPTION',
}
}]
}, bear_put_vertical_close(
'GOOG_012122P2200',
'GOOG_012122P2400',
3, 30.6).build()))
def test_sell_trailing_stop_stock(self):
builder = (
OrderBuilder()
.set_complex_order_strategy_type(ComplexOrderStrategyType.NONE)
.set_order_type(OrderType.TRAILING_STOP)
.set_session(Session.NORMAL)
.set_stop_price_link_basis(StopPriceLinkBasis.BID)
.set_stop_price_link_type(StopPriceLinkType.VALUE)
.set_stop_price_offset(10)
.set_duration(Duration.DAY)
.set_order_strategy_type(OrderStrategyType.SINGLE)
.add_equity_leg(EquityInstruction.SELL, 'XYZ', 10))
expected = {
'complexOrderStrategyType': 'NONE',
'orderType': 'TRAILING_STOP',
'session': 'NORMAL',
'stopPriceLinkBasis': 'BID',
'stopPriceLinkType': 'VALUE',
'stopPriceOffset': 10,
'duration': 'DAY',
'orderStrategyType': 'SINGLE',
'orderLegCollection': [
{
'instruction': 'SELL',
'quantity': 10,
'instrument': {
'symbol': 'XYZ',
'assetType': 'EQUITY'
}
}
]
}
self.assertFalse(has_diff(expected, builder.build()))
def test_conditional_order_one_triggers_another(self):
builder = (
OrderBuilder()
.set_order_type(OrderType.LIMIT)
.set_session(Session.NORMAL)
.set_price(34.97)
.set_duration(Duration.DAY)
.set_order_strategy_type(OrderStrategyType.TRIGGER)
.add_equity_leg(EquityInstruction.BUY, 'XYZ', 10)
.add_child_order_strategy(
OrderBuilder()
.set_order_type(OrderType.LIMIT)
.set_session(Session.NORMAL)
.set_price(42.03)
.set_duration(Duration.DAY)
.set_order_strategy_type(OrderStrategyType.SINGLE)
.add_equity_leg(EquityInstruction.SELL, 'XYZ', 10)))
expected = {
'orderType': 'LIMIT',
'session': 'NORMAL',
'price': '34.97',
'duration': 'DAY',
'orderStrategyType': 'TRIGGER',
'orderLegCollection': [
{
'instruction': 'BUY',
'quantity': 10,
'instrument': {
'symbol': 'XYZ',
'assetType': 'EQUITY'
}
}
],
'childOrderStrategies': [
{
'orderType': 'LIMIT',
'session': 'NORMAL',
'price': '42.03',
'duration': 'DAY',
'orderStrategyType': 'SINGLE',
'orderLegCollection': [
{
'instruction': 'SELL',
'quantity': 10,
'instrument': {
'symbol': 'XYZ',
'assetType': 'EQUITY'
}
}
]
}
]
}
self.assertFalse(has_diff(expected, builder.build()))
def test_option_sell_to_close_market(self):
self.assertFalse(has_diff({
'orderType': 'MARKET',
'session': 'NORMAL',
'duration': 'DAY',
'orderStrategyType': 'SINGLE',
'orderLegCollection': [{
'instruction': 'SELL_TO_CLOSE',
'quantity': 10,
'instrument': {
'symbol': 'GOOG_012122P2200',
'assetType': 'OPTION',
}
}]
}, option_sell_to_close_market('GOOG_012122P2200', 10).build()))
def test_trigger(self):
self.assertFalse(
has_diff(
{
'orderStrategyType': 'TRIGGER',
'session': 'NORMAL',
'childOrderStrategies': [
{
'duration': 'DAY'
},
]
},
first_triggers_second(
OrderBuilder().set_session(Session.NORMAL),
OrderBuilder().set_duration(Duration.DAY)).build()))
