def test_on_take(self):
# given
on_trade_mock = Mock()
self.etherdelta.on_trade(on_trade_mock)
# and
self.etherdelta.approve([self.token1, self.token2], directly())
self.etherdelta.deposit_token(self.token1.address,
Wad.from_number(10)).transact()
self.etherdelta.deposit_token(self.token2.address,
Wad.from_number(10)).transact()
# when
order = self.etherdelta.create_order(pay_token=self.token1.address,
pay_amount=Wad.from_number(2),
buy_token=self.token2.address,
buy_amount=Wad.from_number(4),
expires=100000000)
# and
self.etherdelta.trade(order, Wad.from_number(1.5)).transact()
# then
on_trade = wait_until_mock_called(on_trade_mock)[0]
assert on_trade.maker == self.our_address
assert on_trade.taker == self.our_address
assert on_trade.pay_token == self.token1.address
assert on_trade.buy_token == self.token2.address
assert on_trade.take_amount == Wad.from_number(0.75)
assert on_trade.give_amount == Wad.from_number(1.5)
assert on_trade.raw['blockNumber'] > 0
def test_on_take_wih_filter(self):
# given
on_take_filter1_mock = Mock()
on_take_filter2_mock = Mock()
self.otc.on_take(on_take_filter1_mock,
{'maker': self.our_address.address})
self.otc.on_take(
on_take_filter2_mock,
{'maker': '0x0101010101020202020201010101010303030303'})
# when
self.otc.approve([self.token1], directly())
self.otc.make(pay_token=self.token1.address,
pay_amount=Wad.from_number(1),
buy_token=self.token2.address,
buy_amount=Wad.from_number(2)).transact()
# and
self.otc.approve([self.token2], directly())
self.otc.take(1, Wad.from_number(0.5)).transact()
# then
assert len(wait_until_mock_called(on_take_filter1_mock)) == 1
# and
time.sleep(2)
assert not on_take_filter2_mock.called
def test_on_kill(self):
# given
on_kill_mock = Mock()
self.otc.on_kill(on_kill_mock)
# when
self.otc.approve([self.token1], directly())
self.otc.make(pay_token=self.token1.address,
pay_amount=Wad.from_number(1),
buy_token=self.token2.address,
buy_amount=Wad.from_number(2)).transact()
# and
self.otc.kill(1).transact()
# then
on_kill = wait_until_mock_called(on_kill_mock)[0]
assert on_kill.order_id == 1
assert on_kill.maker == self.our_address
assert on_kill.pay_token == self.token1.address
assert on_kill.pay_amount == Wad.from_number(1)
assert on_kill.buy_token == self.token2.address
assert on_kill.buy_amount == Wad.from_number(2)
assert on_kill.timestamp != 0
assert on_kill.raw['blockNumber'] > 0
def test_on_cancel(self):
# given
on_cancel_mock = Mock()
self.exchange.on_cancel(on_cancel_mock)
# when
self.exchange.approve([self.token1, self.token2], directly())
# when
order = self.exchange.create_order(pay_token=self.token1.address, pay_amount=Wad.from_number(10),
buy_token=self.token2.address, buy_amount=Wad.from_number(4),
expiration=1763920792)
# and
self.exchange.cancel_order(self.exchange.sign_order(order)).transact()
# then
on_cancel = wait_until_mock_called(on_cancel_mock)[0]
assert on_cancel.maker == self.our_address
assert on_cancel.fee_recipient == Address("0x0000000000000000000000000000000000000000")
assert on_cancel.pay_token == self.token1.address
assert on_cancel.cancelled_pay_amount == Wad.from_number(10)
assert on_cancel.buy_token == self.token2.address
assert on_cancel.cancelled_buy_amount == Wad.from_number(4)
assert on_cancel.tokens.startswith('0x')
assert on_cancel.order_hash == self.exchange.get_order_hash(self.exchange.sign_order(order))
assert on_cancel.raw['blockNumber'] > 0
