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_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_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()
# 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_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_replace_pending_transactions_if_model_lowers_bid_and_increases_gas_price(self, auction_id):
# given
(model, model_factory) = models(self.keeper, auction_id)
amount_to_sell = self.surplus_auction_house.bids(auction_id).amount_to_sell
# 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(8.0), gas_price=15)
# and
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert self.surplus_auction_house.bids(auction_id).bid_amount == Wad(amount_to_sell * self.geb.oracle_relayer.redemption_price()) / Wad.from_number(8.0)
assert self.web3.eth.getBlock('latest', full_transactions=True).transactions[0].gasPrice == 15
# cleanup
time_travel_by(self.web3, self.surplus_auction_house.bid_duration() + 1)
assert self.surplus_auction_house.settle_auction(auction_id).transact()
def test_should_not_bid_on_rounding_errors_with_small_amounts(self, auction_id):
# given
(model, model_factory) = models(self.keeper, auction_id)
amount_to_sell = self.surplus_auction_house.bids(auction_id).amount_to_sell
# 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.surplus_auction_house.bids(auction_id).bid_amount == Wad(amount_to_sell * self.geb.oracle_relayer.redemption_price() ) / 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.surplus_auction_house.bid_duration() + 1)
assert self.surplus_auction_house.settle_auction(auction_id).transact()
def test_should_overbid_itself_if_model_has_updated_the_price(self, auction_id):
# given
(model, model_factory) = models(self.keeper, auction_id)
amount_to_sell = self.surplus_auction_house.bids(auction_id).amount_to_sell
# 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.surplus_auction_house.bids(auction_id).bid_amount == Wad(amount_to_sell * self.geb.oracle_relayer.redemption_price() / 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.surplus_auction_house.bids(auction_id).bid_amount == Wad(amount_to_sell * self.geb.oracle_relayer.redemption_price() / Rad(second_bid))
# cleanup
time_travel_by(self.web3, self.surplus_auction_house.bid_duration() + 1)
assert self.surplus_auction_house.settle_auction(auction_id).transact()
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_restart_auction_if_auction_expired_due_to_total_auction_length(self, auction_id):
# given
(model, model_factory) = models(self.keeper, auction_id)
# 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.surplus_auction_house.total_auction_length() + 1)
# and
simulate_model_output(model=model, price=Wad.from_number(9.0))
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
model.terminate.assert_not_called()
auction = self.surplus_auction_house.bids(auction_id)
assert round(Wad(auction.amount_to_sell * self.geb.oracle_relayer.redemption_price() ) / auction.bid_amount, 2) == round(Wad.from_number(9.0), 2)
# cleanup
time_travel_by(self.web3, self.surplus_auction_house.bid_duration() + 1)
model_factory.create_model.assert_called_once()
self.keeper.check_all_auctions()
model.terminate.assert_called_once()
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_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_use_default_gas_price_if_not_provided_by_the_model(
self, kick):
# given
(model, model_factory) = models(self.keeper, kick)
# when
simulate_model_output(model=model, price=Wad.from_number(10.0))
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
auction = self.flapper.bids(kick)
assert auction.guy == self.keeper_address
assert auction.bid > Wad(0)
assert self.web3.eth.getBlock('latest', full_transactions=True).transactions[0].gasPrice == \
self.default_gas_price
print(
f"tx gas price is {self.web3.eth.getBlock('latest', full_transactions=True).transactions[0].gasPrice}, web3.eth.gasPrice is {self.web3.eth.gasPrice}"
)
# cleanup
time_travel_by(self.web3, self.flapper.ttl() + 1)
assert self.flapper.deal(kick).transact()
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_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_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_replace_pending_transactions_if_model_raises_bid_and_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(9.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(8.0),
gas_price=15)
# and
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert round(self.flapper.bids(kick).bid,
2) == round(Wad(lot / Rad.from_number(8.0)), 2)
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_increase_gas_price_of_pending_transactions_if_model_increases_gas_price(self, auction_id):
# given
collateral_auction_house = self.collateral.collateral_auction_house
if not isinstance(collateral_auction_house, FixedDiscountCollateralAuctionHouse):
return
(model, model_factory) = models(self.keeper, auction_id)
# when
bid_price = Wad.from_number(20.0)
reserve_system_coin(self.geb, self.collateral, self.keeper_address, bid_price * bid_size * 2, Wad.from_number(2))
self.keeper.rebalance_system_coin()
simulate_model_output(model=model, price=bid_price, 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=bid_price, gas_price=15)
# and
self.keeper.check_for_bids()
wait_for_other_threads()
# then
#assert collateral_auction_house.bids(auction_id).raised_amount == Rad(bid_price * bid_size)
assert self.web3.eth.getBlock('latest', full_transactions=True).transactions[0].gasPrice == 15
def simulate_model_bid(self, geb: GfDeployment, c: Collateral, model: object,
gas_price: Optional[int] = None):
assert (isinstance(geb, GfDeployment))
assert (isinstance(c, Collateral))
assert (isinstance(gas_price, int)) or gas_price is None
collateral_auction_house = c.collateral_auction_house
initial_bid = collateral_auction_house.bids(model.id)
assert initial_bid.amount_to_sell > Wad(0)
our_bid = Wad.from_number(500) * initial_bid.amount_to_sell
reserve_system_coin(geb, c, self.keeper_address, our_bid, extra_collateral=Wad.from_number(2))
simulate_model_output(model=model, price=Wad.from_number(500), gas_price=gas_price)
def test_should_obey_gas_price_provided_by_the_model(self, kick):
# given
(model, model_factory) = models(self.keeper, kick)
# when
simulate_model_output(model=model, price=Wad.from_number(800.0), gas_price=175000)
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert self.web3.eth.getBlock('latest', full_transactions=True).transactions[0].gasPrice == 175000
def simulate_model_bid(self, model, price: Ray, reserve_dai_for_bid=True):
assert isinstance(price, Ray)
assert price > Ray(0)
assert model.id > 0
sale = self.clipper.sales(model.id)
assert sale.lot > Wad(0)
our_bid = Ray(sale.lot) * price
if reserve_dai_for_bid:
reserve_dai(self.mcd, self.dai_collateral, self.keeper_address, Wad(our_bid) + Wad(1))
simulate_model_output(model=model, price=Wad(price))
def simulate_model_bid(self, mcd: DssDeployment, c: Collateral, model: object,
price: Wad, gas_price: Optional[int] = None):
assert (isinstance(mcd, DssDeployment))
assert (isinstance(c, Collateral))
assert (isinstance(price, Wad))
assert (isinstance(gas_price, int)) or gas_price is None
assert price > Wad(0)
flipper = c.flipper
initial_bid = flipper.bids(model.id)
assert initial_bid.lot > Wad(0)
our_bid = price * initial_bid.lot
reserve_dai(mcd, c, self.keeper_address, our_bid, extra_collateral=Wad.from_number(2))
simulate_model_output(model=model, price=price, gas_price=gas_price)
def test_should_provide_model_with_updated_info_after_our_own_bid(
self, mcd, c, gal_address, keeper):
# given
flipper = c.flipper
kick = flipper.kicks()
(model, model_factory) = models(keeper, kick)
# when
keeper.check_all_auctions()
wait_for_other_threads()
previous_bid = flipper.bids(model.id)
# then
assert model.send_status.call_count == 1
# when
initial_bid = flipper.bids(kick)
our_price = Wad.from_number(30)
our_bid = our_price * initial_bid.lot
reserve_dai(mcd, c, self.keeper_address, our_bid)
simulate_model_output(model=model, price=our_price)
keeper.check_for_bids()
# and
keeper.check_all_auctions()
wait_for_other_threads()
# and
keeper.check_all_auctions()
wait_for_other_threads()
# then
assert model.send_status.call_count > 1
# and
status = model.send_status.call_args[0][0]
assert status.id == kick
assert status.flipper == flipper.address
assert status.flapper is None
assert status.flopper is None
assert status.bid == Rad(our_price * status.lot)
assert status.lot == previous_bid.lot
assert status.tab == previous_bid.tab
assert status.beg > Wad.from_number(1)
assert status.guy == self.keeper_address
assert status.era > 0
assert status.end > status.era
assert status.tic > status.era
assert status.price == our_price
# cleanup
time_travel_by(self.web3, flipper.ttl() + 1)
assert flipper.deal(kick).transact()
def test_should_obey_gas_price_provided_by_the_model(self, auction_id):
# given
(model, model_factory) = models(self.keeper, auction_id)
# when
simulate_model_output(model=model, price=Wad.from_number(10.0), gas_price=175000)
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert self.web3.eth.getBlock('latest', full_transactions=True).transactions[0].gasPrice == 175000
# cleanup
time_travel_by(self.web3, self.surplus_auction_house.bid_duration() + 1)
assert self.surplus_auction_house.settle_auction(auction_id).transact()
def test_should_provide_model_with_updated_info_after_our_own_bid(self):
# given
auction_id = self.debt_auction_house.auctions_started()
(model, model_factory) = models(self.keeper, auction_id)
# when
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert model.send_status.call_count == 1
# when
price = Wad.from_number(250.0)
simulate_model_output(model=model, price=price)
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert model.send_status.call_count > 1
last_bid = self.debt_auction_house.bids(auction_id)
# and
status = model.send_status.call_args[0][0]
assert status.id == auction_id
assert status.collateral_auction_house is None
assert status.surplus_auction_house is None
assert status.debt_auction_house == self.debt_auction_house.address
assert status.bid_amount == last_bid.bid_amount
assert status.amount_to_sell == Wad(
last_bid.bid_amount * self.geb.oracle_relayer.redemption_price() /
Rad(price))
assert status.amount_to_raise is None
assert status.bid_decrease > Wad.from_number(1)
assert status.high_bidder == self.keeper_address
assert status.block_time > 0
assert status.auction_deadline > status.block_time
assert status.bid_expiry > status.block_time
assert status.price == price
# cleanup
time_travel_by(self.web3, self.debt_auction_house.bid_duration() + 1)
assert self.debt_auction_house.settle_auction(auction_id).transact()
def test_should_make_initial_bid(self):
# given
kick = self.flapper.kicks()
(model, model_factory) = models(self.keeper, kick)
# when
simulate_model_output(model=model, price=Wad.from_number(10.0))
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
auction = self.flapper.bids(kick)
assert round(Wad(auction.lot) / auction.bid, 2) == round(Wad.from_number(10.0), 2)
# cleanup
time_travel_by(self.web3, self.flapper.ttl() + 1)
assert self.flapper.deal(kick).transact()
def test_should_make_initial_bid(self):
# given
auction_id = self.surplus_auction_house.auctions_started()
(model, model_factory) = models(self.keeper, auction_id)
# when
simulate_model_output(model=model, price=Wad.from_number(10.0))
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
auction = self.surplus_auction_house.bids(auction_id)
assert round(Wad(auction.amount_to_sell * self.geb.oracle_relayer.redemption_price() ) / auction.bid_amount, 2) == round(Wad.from_number(10.0), 2)
# cleanup
time_travel_by(self.web3, self.surplus_auction_house.bid_duration() + 1)
assert self.surplus_auction_house.settle_auction(auction_id).transact()
def test_should_use_default_gas_price_if_not_provided_by_the_model(self):
# given
kick = self.flopper.kicks()
(model, model_factory) = models(self.keeper, kick)
# when
simulate_model_output(model=model, price=Wad.from_number(850.0))
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert self.web3.eth.getBlock('latest', full_transactions=True).transactions[0].gasPrice == \
self.web3.eth.gasPrice
# cleanup
time_travel_by(self.web3, self.flopper.ttl() + 1)
assert self.flopper.deal(kick).transact()
def test_should_provide_model_with_updated_info_after_our_own_bid(self):
# given
kick = self.flopper.kicks()
(model, model_factory) = models(self.keeper, kick)
# when
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert model.send_status.call_count == 1
# when
price = Wad.from_number(50.0)
simulate_model_output(model=model, price=price)
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# and
self.keeper.check_all_auctions()
wait_for_other_threads()
# then
assert model.send_status.call_count > 1
last_bid = self.flopper.bids(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 == last_bid.bid
assert status.lot == Wad(last_bid.bid / Rad(price))
assert status.tab is None
assert status.beg > Wad.from_number(1)
assert status.guy == self.keeper_address
assert status.era > 0
assert status.end > status.era
assert status.tic > status.era
assert status.price == price
# cleanup
time_travel_by(self.web3, self.flopper.ttl() + 1)
assert self.flopper.deal(kick).transact()
def test_should_use_default_gas_price_if_not_provided_by_the_model(
self, auction_id):
# given
(model, model_factory) = models(self.keeper, auction_id)
# when
simulate_model_output(model=model, price=Wad.from_number(850.0))
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert self.debt_auction_house.bids(
auction_id).high_bidder == self.keeper_address
assert self.web3.eth.getBlock('latest', full_transactions=True).transactions[0].gasPrice == \
self.default_gas_price
# cleanup
time_travel_by(self.web3, self.debt_auction_house.bid_duration() + 1)
assert self.debt_auction_house.settle_auction(auction_id).transact()
def test_should_outbid_a_zero_bid(self, kick):
# given
(model, model_factory) = models(self.keeper, kick)
# and
auction = self.flapper.bids(kick)
assert self.flapper.tend(kick, auction.lot, Wad(1)).transact(from_address=self.other_address)
assert self.flapper.bids(kick).bid == Wad(1)
# when
simulate_model_output(model=model, price=Wad.from_number(0.0000006))
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
auction = self.flapper.bids(kick)
assert round(Wad(auction.lot) / auction.bid, 2) == round(Wad.from_number(0.0000006), 2)
# cleanup
time_travel_by(self.web3, self.flapper.ttl() + 1)
assert self.flapper.deal(kick).transact()
