def test_should_overbid_itself_if_model_has_updated_the_price(self, kick):
# given
(model, model_factory) = models(self.keeper, kick)
lot = self.flapper.bids(kick).lot
# when
first_bid = Wad.from_number(0.0000004)
simulate_model_output(model=model, price=first_bid)
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert self.flapper.bids(kick).bid == Wad(lot / Rad(first_bid))
# when
second_bid = Wad.from_number(0.0000003)
simulate_model_output(model=model, price=second_bid)
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert self.flapper.bids(kick).bid == Wad(lot / Rad(second_bid))
# cleanup
time_travel_by(self.web3, self.flapper.ttl() + 1)
assert self.flapper.deal(kick).transact()
def test_should_replace_pending_transactions_if_model_raises_bid_and_increases_gas_price(
self, kick):
# given
(model, model_factory) = models(self.keeper, kick)
flipper = self.collateral.flipper
# when
reserve_dai(self.mcd, self.collateral, self.keeper_address,
Wad.from_number(35.0) * tend_lot * 2)
simulate_model_output(model=model,
price=Wad.from_number(15.0),
gas_price=10)
# and
self.start_ignoring_transactions()
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
# and
self.end_ignoring_transactions()
# and
simulate_model_output(model=model,
price=Wad.from_number(20.0),
gas_price=15)
# and
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert flipper.bids(kick).bid == Rad(Wad.from_number(20.0) * tend_lot)
assert self.web3.eth.getBlock(
'latest', full_transactions=True).transactions[0].gasPrice == 15
# cleanup
time_travel_by(self.web3, flipper.ttl() + 1)
assert flipper.deal(kick).transact()
def test_should_not_dent_on_rounding_errors_with_small_amounts(self):
# given
flipper = self.collateral.flipper
kick_small_lot = flipper.kicks()
(model, model_factory) = models(self.keeper, kick_small_lot)
# when
auction = flipper.bids(kick_small_lot)
bid_price = Wad(auction.tab / Rad(tend_small_lot))
self.simulate_model_bid(self.mcd, self.collateral, model, bid_price)
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert flipper.bids(kick_small_lot).lot == auction.lot
# when
tx_count = self.web3.eth.getTransactionCount(
self.keeper_address.address)
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert self.web3.eth.getTransactionCount(
self.keeper_address.address) == tx_count
def test_should_terminate_model_if_auction_is_dealt(
self, kick, other_address):
# given
(model, model_factory) = models(self.keeper, kick)
flipper = self.collateral.flipper
# when
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
model_factory.create_model.assert_called_once()
model.terminate.assert_not_called()
# when
self.tend_with_dai(self.mcd, self.collateral, flipper, kick,
other_address, Rad.from_number(90))
# and
time_travel_by(self.web3, flipper.ttl() + 1)
# and
flipper.deal(kick).transact(from_address=other_address)
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
model_factory.create_model.assert_called_once()
model.terminate.assert_called_once()
def test_should_only_tend_if_bid_is_only_slightly_above_tab(self, kick):
# given
(model, model_factory) = models(self.keeper, kick)
flipper = self.collateral.flipper
# when
auction = flipper.bids(kick)
bid_price = Wad(auction.tab) + Wad.from_number(0.1)
self.simulate_model_bid(self.mcd, self.collateral, model, bid_price)
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
auction = flipper.bids(kick)
assert auction.bid == auction.tab
assert auction.lot == tend_lot
# when
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
auction = flipper.bids(kick)
assert auction.bid == auction.tab
assert auction.lot == tend_lot
# cleanup
time_travel_by(self.web3, flipper.ttl() + 1)
assert flipper.deal(kick).transact()
def test_should_overbid_itself_if_model_has_updated_the_price(self, kick):
# given
(model, model_factory) = models(self.keeper, kick)
# when
simulate_model_output(model=model, price=Wad.from_number(100.0))
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert round(Rad(self.flopper.bids(kick).lot),
2) == round(self.sump / Rad.from_number(100.0), 2)
# when
simulate_model_output(model=model, price=Wad.from_number(110.0))
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert self.lot_implies_price(kick, Wad.from_number(110.0))
# cleanup
time_travel_by(self.web3, self.flopper.ttl() + 1)
assert self.flopper.deal(kick).transact()
def test_should_start_a_new_model_and_provide_it_with_info_on_auction_kick(
self, kick):
# given
(model, model_factory) = models(self.keeper, kick)
# when
self.keeper.check_all_auctions()
wait_for_other_threads()
initial_bid = self.collateral.flipper.bids(kick)
# then
model_factory.create_model.assert_called_once_with(
Parameters(flipper=self.collateral.flipper.address,
flapper=None,
flopper=None,
id=kick))
# and
status = model.send_status.call_args[0][0]
assert status.id == kick
assert status.flipper == self.collateral.flipper.address
assert status.flapper is None
assert status.flopper is None
assert status.bid == Rad.from_number(0)
assert status.lot == initial_bid.lot
assert status.tab == initial_bid.tab
assert status.beg > Wad.from_number(1)
assert status.guy == self.mcd.cat.address
assert status.era > 0
assert status.end < status.era + self.collateral.flipper.tau() + 1
assert status.tic == 0
assert status.price == Wad(0)
# cleanup
time_travel_by(self.web3, self.collateral.flipper.ttl() + 1)
def test_should_sequentially_tend_and_dent_if_price_takes_us_to_the_dent_phrase(self, kick, keeper_address):
# given
flipper = self.collateral.flipper
(model, model_factory) = models(self.keeper, kick)
# when
our_bid_price = Wad.from_number(150)
assert our_bid_price * flipper.bids(kick).lot > Wad(flipper.bids(1).tab)
self.simulate_model_bid(self.mcd, self.collateral, model, our_bid_price)
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
auction = flipper.bids(kick)
assert auction.bid == auction.tab
assert auction.lot == tend_lot
# when
reserve_dai(self.mcd, self.collateral, keeper_address, Wad(auction.tab))
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
auction = flipper.bids(kick)
assert auction.bid == auction.tab
assert auction.lot < tend_lot
assert round(auction.bid / Rad(auction.lot), 2) == round(Rad(our_bid_price), 2)
# cleanup
time_travel_by(self.web3, flipper.ttl() + 1)
assert flipper.deal(kick).transact()
def test_should_replace_pending_transactions_if_model_lowers_bid_and_increases_gas_price(self, kick):
""" Assuming we want all bids to be submitted as soon as output from the model is parsed,
this test seems impractical. In real applications, the model would be unable to submit a lower bid. """
# given
(model, model_factory) = models(self.keeper, kick)
flipper = self.collateral.flipper
assert self.mcd.web3 == self.web3
# when
bid_price = Wad.from_number(20.0)
reserve_dai(self.mcd, self.collateral, self.keeper_address, bid_price * tend_lot)
simulate_model_output(model=model, price=Wad.from_number(20.0), gas_price=10)
# and
self.start_ignoring_transactions()
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
# and
self.end_ignoring_transactions()
# and
simulate_model_output(model=model, price=Wad.from_number(15.0), gas_price=15)
# and
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert flipper.bids(kick).bid == Rad(Wad.from_number(15.0) * tend_lot)
assert self.web3.eth.getBlock('latest', full_transactions=True).transactions[0].gasPrice == 15
# cleanup
time_travel_by(self.web3, flipper.ttl() + 1)
assert flipper.deal(kick).transact()
def test_should_terminate_model_if_auction_expired_due_to_tau(
self, c, keeper):
# given
flipper = c.flipper
kick = flipper.kicks()
(model, model_factory) = models(keeper, kick)
# when
keeper.check_all_auctions()
wait_for_other_threads()
# then
model_factory.create_model.assert_called_once()
model.terminate.assert_not_called()
# when
time_travel_by(self.web3, flipper.tau() + 1)
# and
keeper.check_all_auctions()
wait_for_other_threads()
# then
model_factory.create_model.assert_called_once()
model.terminate.assert_called_once()
# cleanup
assert flipper.deal(kick).transact()
def test_should_increase_gas_price_of_pending_transactions_if_model_increases_gas_price(
self, mcd, c, kick, keeper):
# given
(model, model_factory) = models(keeper, kick)
flipper = c.flipper
# when
bid_price = Wad.from_number(20.0)
reserve_dai(mcd, c, self.keeper_address, bid_price * tend_lot * 2)
simulate_model_output(model=model, price=bid_price, gas_price=10)
# and
self.start_ignoring_transactions()
# and
keeper.check_all_auctions()
keeper.check_for_bids()
# and
simulate_model_output(model=model, price=bid_price, gas_price=15)
# and
self.end_ignoring_transactions()
# and
keeper.check_for_bids()
wait_for_other_threads()
# then
assert flipper.bids(kick).bid == Rad(bid_price * tend_lot)
assert self.web3.eth.getBlock(
'latest', full_transactions=True).transactions[0].gasPrice == 15
# cleanup
time_travel_by(self.web3, flipper.ttl() + 1)
assert flipper.deal(kick).transact()
def test_should_deal_when_we_won_the_auction(self, kick):
# given
(model, model_factory) = models(self.keeper, kick)
# when
simulate_model_output(model=model, price=Wad.from_number(8.0))
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
auction = self.flapper.bids(kick)
assert auction.bid > Wad(0)
assert round(Wad(auction.lot) / auction.bid,
2) == round(Wad.from_number(8.0), 2)
dai_before = self.mcd.vat.dai(self.keeper_address)
# when
time_travel_by(self.web3, self.flapper.ttl() + 1)
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
dai_after = self.mcd.vat.dai(self.keeper_address)
# then
assert dai_before < dai_after
def test_should_not_bid_on_rounding_errors_with_small_amounts(self, kick):
# given
(model, model_factory) = models(self.keeper, kick)
lot = self.flapper.bids(kick).lot
# when
price = Wad.from_number(9.0) - Wad(5)
simulate_model_output(model=model, price=price)
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert self.flapper.bids(kick).bid == Wad(lot) / Wad(price)
# when
tx_count = self.web3.eth.getTransactionCount(
self.keeper_address.address)
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert self.web3.eth.getTransactionCount(
self.keeper_address.address) == tx_count
# cleanup
time_travel_by(self.web3, self.flapper.ttl() + 1)
assert self.flapper.deal(kick).transact()
def test_should_increase_gas_price_of_pending_transactions_if_model_increases_gas_price(
self, kick):
# given
(model, model_factory) = models(self.keeper, kick)
lot = self.flapper.bids(kick).lot
# when
simulate_model_output(model=model,
price=Wad.from_number(10.0),
gas_price=10)
# and
self.start_ignoring_transactions()
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
# and
self.end_ignoring_transactions()
# and
simulate_model_output(model=model,
price=Wad.from_number(10.0),
gas_price=15)
# and
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert self.flapper.bids(kick).bid == Wad(lot) / Wad.from_number(10.0)
assert self.web3.eth.getBlock(
'latest', full_transactions=True).transactions[0].gasPrice == 15
# cleanup
time_travel_by(self.web3, self.flapper.ttl() + 1)
assert self.flapper.deal(kick).transact()
def test_should_terminate_model_if_auction_expired_due_to_ttl_and_somebody_else_won_it(
self, kick):
# given
(model, model_factory) = models(self.keeper, kick)
# when
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
model_factory.create_model.assert_called_once()
model.terminate.assert_not_called()
# when
self.dent(kick, self.other_address, Wad.from_number(0.000015),
self.sump)
# and
time_travel_by(self.web3, self.flopper.ttl() + 1)
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
model_factory.create_model.assert_called_once()
model.terminate.assert_called_once()
# cleanup
assert self.flopper.deal(kick).transact()
def test_should_start_a_new_model_and_provide_it_with_info_on_auction_kick(
self, bid_id, d, keeper, c):
# given
(model, model_factory) = self.models(keeper)
# when
keeper.check_all_auctions()
wait_for_other_threads()
# then
model_factory.create_model.assert_called_once_with(
Parameters(flipper=c.flipper.address,
flapper=None,
flopper=None,
id=bid_id))
# and
assert model.send_status.call_args[0][0].id == bid_id
assert model.send_status.call_args[0][0].flipper == c.flipper.address
assert model.send_status.call_args[0][0].flapper is None
assert model.send_status.call_args[0][0].flopper is None
assert model.send_status.call_args[0][0].bid == Wad.from_number(0)
assert model.send_status.call_args[0][0].lot == Wad(684931506849315068)
assert model.send_status.call_args[0][0].tab == Wad.from_number(100)
assert model.send_status.call_args[0][0].beg == Ray.from_number(1.05)
assert model.send_status.call_args[0][0].guy == d.cat.address
assert model.send_status.call_args[0][0].era > 0
assert model.send_status.call_args[
0][0].end < model.send_status.call_args[0][0].era + c.flipper.tau(
) + 1
assert model.send_status.call_args[0][0].tic == 0
assert model.send_status.call_args[0][0].price == Wad(0)
def test_should_bid_even_if_there_is_already_a_bidder(self, kick):
# given
(model, model_factory) = models(self.keeper, kick)
mkr_before = self.mcd.mkr.balance_of(self.keeper_address)
# and
lot = Wad.from_number(0.000016)
assert self.flopper.dent(
kick, lot, self.sump).transact(from_address=self.other_address)
assert self.flopper.bids(kick).lot == lot
# when
simulate_model_output(model=model, price=Wad.from_number(825.0))
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
auction = self.flopper.bids(kick)
assert auction.lot != lot
assert round(auction.bid / Rad(auction.lot),
2) == round(Rad.from_number(825.0), 2)
mkr_after = self.mcd.mkr.balance_of(self.keeper_address)
assert mkr_before == mkr_after
# cleanup
time_travel_by(self.web3, self.flopper.ttl() + 1)
assert self.flopper.deal(kick).transact()
def test_should_terminate_model_if_auction_is_dealt(self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
self.model_factory.create_model.assert_called_once()
self.model.terminate.assert_not_called()
# when
self.flipper.tend(
1, Wad.from_number(100),
Wad.from_number(1600)).transact(from_address=self.other_address)
# and
time_travel_by(self.web3, self.flipper.ttl() + 5)
# and
self.flipper.deal(1).transact(from_address=self.other_address)
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
self.model_factory.create_model.assert_called_once()
self.model.terminate.assert_called_once()
def test_should_replace_pending_transactions_if_model_lowers_bid_and_increases_gas_price(
self, kick):
# given
(model, model_factory) = models(self.keeper, kick)
# when
simulate_model_output(model=model,
price=Wad.from_number(80.0),
gas_price=10)
# and
self.start_ignoring_transactions()
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
# and
time.sleep(2)
# and
self.end_ignoring_transactions()
# and
simulate_model_output(model=model,
price=Wad.from_number(70.0),
gas_price=15)
# and
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert self.lot_implies_price(kick, Wad.from_number(70.0))
assert self.web3.eth.getBlock(
'latest', full_transactions=True).transactions[0].gasPrice == 15
# cleanup
time_travel_by(self.web3, self.flopper.ttl() + 1)
assert self.flopper.deal(kick).transact()
def test_should_sequentially_tend_and_dent_if_price_takes_us_to_the_dent_phrase(
self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.simulate_model_output(price=Wad.from_number(80.0))
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
auction = self.flipper.bids(1)
assert self.flipper.bids(1).bid == Wad.from_number(5000)
assert self.flipper.bids(1).lot == Wad.from_number(100)
assert round(auction.bid / auction.lot,
2) == round(Wad.from_number(50.0), 2)
# when
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
auction = self.flipper.bids(1)
assert self.flipper.bids(1).bid == Wad.from_number(5000)
assert self.flipper.bids(1).lot == Wad.from_number(62.5)
assert round(auction.bid / auction.lot,
2) == round(Wad.from_number(80.0), 2)
def test_should_terminate_model_if_auction_expired_due_to_ttl_and_somebody_else_won_it(
self, kick, other_address):
# given
(model, model_factory) = models(self.keeper, kick)
flipper = self.collateral.flipper
# when
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
model_factory.create_model.assert_called_once()
model.terminate.assert_not_called()
# when
flipper.approve(
flipper.vat(),
approval_function=hope_directly(from_address=other_address))
new_bid_amount = Rad.from_number(85)
self.tend_with_dai(self.mcd, self.collateral, flipper, kick,
other_address, new_bid_amount)
# and
time_travel_by(self.web3, flipper.ttl() + 1)
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
model_factory.create_model.assert_called_once()
model.terminate.assert_called_once()
# cleanup
assert flipper.deal(kick).transact()
def test_should_use_most_up_to_date_price_for_dent_even_if_it_gets_updated_during_tend(
self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.simulate_model_output(price=Wad.from_number(80.0))
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
auction = self.flipper.bids(1)
assert self.flipper.bids(1).bid == Wad.from_number(5000)
assert self.flipper.bids(1).lot == Wad.from_number(100)
assert round(auction.bid / auction.lot,
2) == round(Wad.from_number(50.0), 2)
# when
self.simulate_model_output(price=Wad.from_number(100.0))
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
auction = self.flipper.bids(1)
assert self.flipper.bids(1).bid == Wad.from_number(5000)
assert self.flipper.bids(1).lot == Wad.from_number(50.0)
assert round(auction.bid / auction.lot,
2) == round(Wad.from_number(100.0), 2)
def test_should_use_most_up_to_date_price_for_dent_even_if_it_gets_updated_during_tend(
self, kick):
# given
(model, model_factory) = models(self.keeper, kick)
flipper = self.collateral.flipper
# when
first_bid_price = Wad.from_number(140)
self.simulate_model_bid(self.mcd, self.collateral, model,
first_bid_price)
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
auction = flipper.bids(kick)
assert auction.bid == auction.tab
assert auction.lot == tend_lot
# when
second_bid_price = Wad.from_number(150)
self.simulate_model_bid(self.mcd, self.collateral, model,
second_bid_price)
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
auction = flipper.bids(kick)
assert auction.bid == auction.tab
assert auction.lot == Wad(auction.bid / Rad(second_bid_price))
# cleanup
time_travel_by(self.web3, flipper.ttl() + 1)
assert flipper.deal(kick).transact()
def test_should_tend_up_to_exactly_tab_if_bid_is_only_slightly_below_tab(
self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.simulate_model_output(price=Wad.from_number(49.99))
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
auction = self.flipper.bids(1)
assert self.flipper.bids(1).bid == Wad.from_number(4999)
assert self.flipper.bids(1).lot == Wad.from_number(100)
assert round(auction.bid / auction.lot,
2) == round(Wad.from_number(49.99), 2)
# when
self.simulate_model_output(price=Wad.from_number(50.0))
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
auction = self.flipper.bids(1)
assert self.flipper.bids(1).bid == Wad.from_number(5000)
assert self.flipper.bids(1).lot == Wad.from_number(100)
assert round(auction.bid / auction.lot,
2) == round(Wad.from_number(50.0), 2)
def test_should_overbid_itself_if_model_has_updated_the_price(self, kick):
# given
(model, model_factory) = models(self.keeper, kick)
flipper = self.collateral.flipper
# when
first_bid = Wad.from_number(15.0)
self.simulate_model_bid(self.mcd, self.collateral, model, first_bid)
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert flipper.bids(kick).bid == Rad(first_bid * tend_lot)
# when
second_bid = Wad.from_number(20.0)
self.simulate_model_bid(self.mcd, self.collateral, model, second_bid)
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert flipper.bids(kick).bid == Rad(second_bid * tend_lot)
# cleanup
time_travel_by(self.web3, flipper.ttl() + 1)
assert flipper.deal(kick).transact()
def test_should_replace_pending_transactions_if_model_lowers_bid_and_increases_gas_price(
self):
# given
self.flipper.kick(self.gal_address, self.gal_address, Wad.from_number(5000), Wad.from_number(100),
Wad.from_number(1000)) \
.transact(from_address=self.gal_address)
# when
self.simulate_model_output(price=Wad.from_number(20.0), gas_price=10)
# and
self.start_ignoring_transactions()
# and
self.keeper.check_all_auctions()
# and
time.sleep(5)
# and
self.end_ignoring_transactions()
# and
self.simulate_model_output(price=Wad.from_number(15.0), gas_price=15)
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert self.flipper.bids(1).bid == Wad.from_number(1500.0)
assert self.web3.eth.getBlock(
'latest', full_transactions=True).transactions[0].gasPrice == 15
def test_should_not_tend_on_rounding_errors_with_small_amounts(
self, kick_small_lot):
# given
(model, model_factory) = models(self.keeper, kick_small_lot)
flipper = self.collateral.flipper
# when
bid_price = Wad.from_number(3.0)
self.simulate_model_bid(self.mcd, self.collateral, model, bid_price)
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert flipper.bids(kick_small_lot).bid == Rad(bid_price *
tend_small_lot)
# when
tx_count = self.web3.eth.getTransactionCount(
self.keeper_address.address)
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert self.web3.eth.getTransactionCount(
self.keeper_address.address) == tx_count
def test_should_tick_if_auction_expired_due_to_tau(self, kick):
# given
(model, model_factory) = models(self.keeper, kick)
# when
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
model_factory.create_model.assert_called_once()
model.terminate.assert_not_called()
# when
time_travel_by(self.web3, self.flopper.tau() + 1)
# and
simulate_model_output(model=model, price=Wad.from_number(555.0))
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
model.terminate.assert_not_called()
auction = self.flopper.bids(kick)
assert round(auction.bid / Rad(auction.lot),
2) == round(Rad.from_number(555.0), 2)
# cleanup
time_travel_by(self.web3, self.flopper.ttl() + 1)
model_factory.create_model.assert_called_once()
self.keeper.check_all_auctions()
model.terminate.assert_called_once()
def test_should_start_a_new_model_and_provide_it_with_info_on_auction_kick(
self, kick):
# given
(model, model_factory) = models(self.keeper, kick)
# when
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
model_factory.create_model.assert_called_once_with(
Parameters(flipper=None,
flapper=None,
flopper=self.flopper.address,
id=kick))
# and
status = model.send_status.call_args[0][0]
assert status.id == kick
assert status.flipper is None
assert status.flapper is None
assert status.flopper == self.flopper.address
assert status.bid > Rad.from_number(0)
assert status.lot == self.mcd.vow.dump()
assert status.tab is None
assert status.beg > Wad.from_number(1)
assert status.guy == self.mcd.vow.address
assert status.era > 0
assert status.end < status.era + self.flopper.tau() + 1
assert status.tic == 0
assert status.price == Wad(status.bid / Rad(status.lot))
def test_should_terminate_model_if_auction_is_dealt(self, kick):
# given
kick = self.flapper.kicks()
(model, model_factory) = models(self.keeper, kick)
# when
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
model_factory.create_model.assert_called_once()
model.terminate.assert_not_called()
# when
auction = self.flapper.bids(kick)
assert self.flapper.tend(
kick, auction.lot,
Wad.from_number(40)).transact(from_address=self.other_address)
# and
time_travel_by(self.web3, self.flapper.ttl() + 1)
# and
assert self.flapper.deal(kick).transact(
from_address=self.other_address)
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
model_factory.create_model.assert_called_once()
model.terminate.assert_called_once()
