def accept_offer(self,
offer_or_id,
buyer,
*,
energy=None,
time=None,
already_tracked=False,
trade_rate: float = None,
trade_bid_info=None,
buyer_origin=None):
if isinstance(offer_or_id, Offer):
offer_or_id = offer_or_id.id
offer = self.offers.pop(offer_or_id, None)
if offer is None:
assert False
self.calls_energy.append(energy)
self.calls_offers.append(offer)
if energy < offer.energy:
residual_energy = offer.energy - energy
residual = Offer('res', offer.price, residual_energy, offer.seller)
traded = Offer(offer.id, offer.price, energy, offer.seller)
return Trade('trade_id', time, traded, traded.seller, buyer,
residual)
else:
return Trade('trade_id', time, offer, offer.seller, buyer)
def test_matching_list_affects_only_matches_after_start_index(self):
matchings = [
BidOfferMatch(offer=Offer('offer_id', 1, 1, 'S'),
offer_energy=1,
bid=Bid('bid_id', 1, 1, 'B', 'S'),
bid_energy=1),
BidOfferMatch(offer=Offer('offer_id2', 2, 2, 'S'),
offer_energy=2,
bid=Bid('bid_id2', 2, 2, 'B', 'S'),
bid_energy=2),
BidOfferMatch(offer=Offer('offer_id', 1, 1, 'S'),
offer_energy=1,
bid=Bid('bid_id', 1, 1, 'B', 'S'),
bid_energy=1)
]
offer_trade = Trade('trade',
1,
Offer('offer_id', 1, 1, 'S'),
'S',
'B',
residual=Offer('residual_offer', 0.5, 0.5, 'S'))
bid_trade = Trade('bid_trade',
1,
Bid('bid_id2', 1, 1, 'S', 'B'),
'S',
'B',
residual=Bid('residual_bid_2', 1, 1, 'S', 'B'))
matchings = TwoSidedPayAsClear._replace_offers_bids_with_residual_in_matching_list(
matchings, 1, offer_trade, bid_trade)
assert len(matchings) == 3
assert matchings[0].offer.id == 'offer_id'
assert matchings[1].bid.id == 'residual_bid_2'
assert matchings[2].offer.id == 'residual_offer'
def test_matching_list_gets_updated_with_residual_offers(self):
matchings = [
BidOfferMatch(offer=Offer('offer_id', pendulum.now(), 1, 1, 'S'),
offer_energy=1,
bid=Bid('bid_id', pendulum.now(), 1, 1, 'B', 'S'),
bid_energy=1),
BidOfferMatch(offer=Offer('offer_id2', pendulum.now(), 2, 2, 'S'),
offer_energy=2,
bid=Bid('bid_id2', pendulum.now(), 2, 2, 'B', 'S'),
bid_energy=2)
]
offer_trade = Trade('trade',
1,
Offer('offer_id', pendulum.now(), 1, 1, 'S'),
'S',
'B',
residual=Offer('residual_offer', pendulum.now(),
0.5, 0.5, 'S'))
bid_trade = Trade('bid_trade',
1,
Bid('bid_id2', pendulum.now(), 1, 1, 'S', 'B'),
'S',
'B',
residual=Bid('residual_bid_2', pendulum.now(), 1, 1,
'S', 'B'))
matchings = TwoSidedPayAsClear._replace_offers_bids_with_residual_in_matching_list(
matchings, 0, offer_trade, bid_trade)
assert len(matchings) == 2
assert matchings[0].offer.id == 'residual_offer'
assert matchings[1].bid.id == 'residual_bid_2'
def test_energy_origin(storage_strategy_test15, market_test15):
storage_strategy_test15.event_activate()
assert len(storage_strategy_test15.state.get_used_storage_share) == 1
assert storage_strategy_test15.state.get_used_storage_share[0] == EnergyOrigin(
ESSEnergyOrigin.EXTERNAL, 15)
storage_strategy_test15.area.current_market.trade = \
Trade('id', 'time', Offer('id', 20, 1.0, 'ChildArea'), 'ChildArea', 'FakeArea')
storage_strategy_test15.event_trade(market_id=market_test15.id,
trade=storage_strategy_test15.area.current_market.trade)
assert len(storage_strategy_test15.state.get_used_storage_share) == 2
assert storage_strategy_test15.state.get_used_storage_share == [EnergyOrigin(
ESSEnergyOrigin.EXTERNAL, 15), EnergyOrigin(ESSEnergyOrigin.LOCAL, 1)]
storage_strategy_test15.area.current_market.trade = \
Trade('id', 'time', Offer('id', 20, 2.0, 'FakeArea'), 'FakeArea', 'A')
storage_strategy_test15.event_trade(market_id=market_test15.id,
trade=storage_strategy_test15.area.current_market.trade)
assert len(storage_strategy_test15.state.get_used_storage_share) == 2
assert storage_strategy_test15.state.get_used_storage_share == [EnergyOrigin(
ESSEnergyOrigin.EXTERNAL, 13), EnergyOrigin(ESSEnergyOrigin.LOCAL, 1)]
storage_strategy_test15.area.current_market.trade = \
Trade('id', 'time', Offer('id', 20, 1.0, 'ParentArea'), 'FakeArea', 'FakeArea')
storage_strategy_test15.event_trade(market_id=market_test15.id,
trade=storage_strategy_test15.area.current_market.trade)
assert len(storage_strategy_test15.state.get_used_storage_share) == 3
assert storage_strategy_test15.state.get_used_storage_share == [EnergyOrigin(
ESSEnergyOrigin.EXTERNAL, 13), EnergyOrigin(ESSEnergyOrigin.LOCAL, 1),
EnergyOrigin(ESSEnergyOrigin.EXTERNAL, 1)]
def accept_bid(self,
bid: Bid,
energy: float = None,
seller: str = None,
buyer: str = None,
already_tracked: bool = False,
trade_rate: float = None,
trade_offer_info=None,
time=None,
seller_origin=None):
self.calls_energy_bids.append(energy)
self.calls_bids.append(bid)
self.calls_bids_price.append(bid.price)
if trade_rate is None:
trade_rate = bid.price / bid.energy
else:
assert trade_rate <= (bid.price / bid.energy)
market_bid = [b for b in self.bids.values() if b.id == bid.id][0]
if energy < market_bid.energy:
residual_energy = bid.energy - energy
residual = Bid('res', bid.price, residual_energy, bid.buyer,
seller)
traded = Bid(bid.id, (trade_rate * energy), energy, bid.buyer,
seller)
return Trade('trade_id', time, traded, traded.seller, bid.buyer,
residual)
else:
traded = Bid(bid.id, (trade_rate * energy), energy, bid.buyer,
seller)
return Trade('trade_id', time, traded, traded.seller, bid.buyer)
def accept_bid(self,
bid,
energy,
seller,
buyer=None,
*,
time=None,
trade_rate: float = None,
trade_offer_info=None,
already_tracked=False,
seller_origin=None,
seller_origin_id=None,
seller_id=None):
self.calls_energy_bids.append(energy)
self.calls_bids.append(bid)
self.calls_bids_price.append(bid.price)
if trade_rate is None:
trade_rate = bid.energy_rate
else:
assert trade_rate <= bid.energy_rate
market_bid = [b for b in self._bids if b.id == bid.id][0]
if energy < market_bid.energy:
residual_energy = bid.energy - energy
residual = Bid('res',
bid.time,
bid.price,
residual_energy,
bid.buyer,
buyer_origin='res')
traded = Bid(bid.id,
bid.time, (trade_rate * energy),
energy,
bid.buyer,
buyer_origin='res')
return Trade('trade_id',
time,
traded,
seller,
bid.buyer,
residual,
buyer_origin=bid.buyer_origin,
seller_origin=seller_origin,
seller_id=seller_id)
else:
traded = Bid(bid.id,
bid.time, (trade_rate * energy),
energy,
bid.buyer,
buyer_origin=bid.id)
return Trade('trade_id',
time,
traded,
seller,
bid.buyer,
buyer_origin=bid.buyer_origin,
seller_origin=seller_origin,
seller_id=seller_id)
def accept_offer(self, offer, buyer, *, energy=None, time=None, price_drop=False):
self.calls_energy.append(energy)
self.calls_offers.append(offer)
if energy < offer.energy:
residual_energy = offer.energy - energy
residual = Offer('res', offer.price, residual_energy, offer.seller, offer.market)
traded = Offer(offer.id, offer.price, energy, offer.seller, offer.market)
return Trade('trade_id', time, traded, traded.seller, buyer, residual)
else:
return Trade('trade_id', time, offer, offer.seller, buyer)
def accept_bid(self, bid, energy, seller, buyer=None, already_tracked=True, *,
time=None, price_drop=True):
self.calls_energy_bids.append(energy)
self.calls_bids.append(bid)
self.calls_bids_price.append(bid.price)
if energy < bid.energy:
residual_energy = bid.energy - energy
residual = Bid('res', bid.price, residual_energy, bid.buyer, seller, bid.market)
traded = Bid(bid.id, bid.price, energy, bid.buyer, seller, bid.market)
return Trade('trade_id', time, traded, traded.seller, bid.buyer, residual)
else:
return Trade('trade_id', time, bid, bid.seller, bid.buyer)
def accept_offer(self, offer, buyer, *, energy=None, time=None, already_tracked=False,
trade_rate: float = None, trade_bid_info=None, buyer_origin=None):
self.calls_energy.append(energy)
self.calls_offers.append(offer)
if energy < offer.energy:
residual_energy = offer.energy - energy
residual = Offer('res', offer.price, residual_energy, offer.seller,
seller_origin='res')
traded = Offer(offer.id, offer.price, energy, offer.seller, seller_origin='res')
return Trade('trade_id', time, traded, traded.seller, buyer, residual,
seller_origin=offer.seller_origin, buyer_origin=buyer_origin)
else:
return Trade('trade_id', time, offer, offer.seller, buyer,
seller_origin=offer.seller_origin, buyer_origin=buyer_origin)
def test_event_trade_after_offer_changed_partial_offer(area_test2, commercial_test2):
original_offer = Offer(id="old_id", time=pendulum.now(),
price=20, energy=1, seller="FakeArea")
accepted_offer = Offer(id="old_id", time=pendulum.now(),
price=15, energy=0.75, seller="FakeArea")
residual_offer = Offer(id="res_id", time=pendulum.now(),
price=5, energy=0.25, seller="FakeArea")
commercial_test2.offers.post(original_offer, area_test2.test_market.id)
commercial_test2.event_offer_split(market_id=area_test2.test_market.id,
original_offer=original_offer,
accepted_offer=accepted_offer,
residual_offer=residual_offer)
assert original_offer.id in commercial_test2.offers.split
assert commercial_test2.offers.split[original_offer.id] == accepted_offer
commercial_test2.event_trade(market_id=area_test2.test_market.id,
trade=Trade(id="id",
time="time",
offer_bid=original_offer,
seller="FakeArea",
buyer="buyer")
)
assert residual_offer in commercial_test2.offers.posted
assert commercial_test2.offers.posted[residual_offer] == area_test2.test_market.id
assert len(commercial_test2.offers.posted) == 1
assert len(commercial_test2.offers.split) == 1
assert len(commercial_test2.offers.sold) == 1
assert original_offer in commercial_test2.offers.sold_in_market(area_test2.test_market.id)
def test_iaa_event_trade_bid_updates_forwarded_bids_on_partial(iaa_bid, called, partial):
iaa_bid.lower_market.delete_bid = called
low_to_high_engine = iaa_bid.engines[0]
iaa_bid._get_market_from_market_id = lambda x: low_to_high_engine.markets.target
if partial:
accepted_bid = Bid(*low_to_high_engine.markets.target._bids[0])
accepted_bid = \
accepted_bid._replace(price=(accepted_bid.energy-0.2) *
(accepted_bid.price/accepted_bid.energy),
energy=accepted_bid.energy-0.2)
partial_bid = Bid('1234', 12, 0.2, 'owner', 'someone_else')
low_to_high_engine.event_bid_changed(market_id=low_to_high_engine.markets.target,
existing_bid=accepted_bid,
new_bid=partial_bid)
else:
accepted_bid = low_to_high_engine.markets.target._bids[0]
partial_bid = False
source_bid = list(low_to_high_engine.markets.source.bids.values())[0]
target_bid = list(low_to_high_engine.markets.target.bids.values())[0]
bidinfo = BidInfo(source_bid=source_bid, target_bid=target_bid)
low_to_high_engine.forwarded_bids[source_bid.id] = bidinfo
low_to_high_engine.forwarded_bids[target_bid.id] = bidinfo
low_to_high_engine.event_bid_traded(
bid_trade=Trade('trade_id',
pendulum.now(tz=TIME_ZONE),
accepted_bid,
seller='someone_else',
buyer='owner',
residual=partial_bid))
assert source_bid.id not in low_to_high_engine.forwarded_bids
assert target_bid.id not in low_to_high_engine.forwarded_bids
if partial:
assert partial_bid.id in low_to_high_engine.forwarded_bids
def test_iaa_event_trade_deletes_forwarded_offer_when_sold(iaa, called):
iaa.lower_market.delete_offer = called
iaa.event_trade(trade=Trade('trade_id', pendulum.now(tz=TIME_ZONE),
iaa.higher_market.offers['id3'], 'owner',
'someone_else'),
market_id=iaa.higher_market.id)
assert len(iaa.lower_market.delete_offer.calls) == 1
def test_publish_event_subscribes_to_response_and_publishes(self):
offer = Offer("1", now(), 2, 3, "A")
trade = Trade("2", now(), Offer("accepted", now(), 7, 8, "Z"), "B",
"C")
new_offer = Offer("3", now(), 4, 5, "D")
existing_offer = Offer("4", now(), 5, 6, "E")
kwargs = {
"offer": offer,
"trade": trade,
"new_offer": new_offer,
"existing_offer": existing_offer
}
self.publisher.publish_event(MarketEvent.OFFER, **kwargs)
self.publisher.redis.sub_to_channel.assert_called_once_with(
"market/test_id/notify_event/response",
self.publisher.response_callback)
expected_result = {k: v.to_JSON_string() for k, v in kwargs.items()}
self.publisher.redis.publish.assert_called_once()
assert self.publisher.redis.publish.call_args_list[0][0][0] == \
"market/test_id/notify_event"
publish_call_args = json.loads(
self.publisher.redis.publish.call_args_list[0][0][1])
assert publish_call_args["event_type"] == MarketEvent.OFFER.value
assert len(DeepDiff(publish_call_args["kwargs"], expected_result)) == 0
def test_accept_bid_calls_market_method_and_publishes_response(self):
bid = Bid("b_id", now(), 12, 13, "b_buyer", "b_seller")
payload = {
"data":
json.dumps({
"seller": "mykonos",
"energy": 12,
"bid": bid.to_JSON_string(),
"transaction_uuid": "trans_id"
})
}
trade = Trade(id="trade_id",
time=now(),
offer=bid,
seller="trade_seller",
buyer="trade_buyer")
self.market.accept_bid = MagicMock(return_value=trade)
self.subscriber._accept_bid(payload)
self.subscriber.market.accept_bid.assert_called_once()
self.subscriber.redis_db.publish.assert_called_once_with(
"id/ACCEPT_BID/RESPONSE",
json.dumps({
"status": "ready",
"trade": trade.to_JSON_string(),
"transaction_uuid": "trans_id"
}))
def test_accept_offer_calls_market_method_and_publishes_response(self):
offer = Offer("o_id", now(), 12, 13, "o_seller")
payload = {
"data":
json.dumps({
"buyer": "mykonos",
"energy": 12,
"offer_or_id": offer.to_JSON_string(),
"transaction_uuid": "trans_id"
})
}
trade = Trade(id="trade_id",
time=now(),
offer=offer,
seller="trade_seller",
buyer="trade_buyer")
self.market.accept_offer = MagicMock(return_value=trade)
self.subscriber._accept_offer(payload)
sleep(0.01)
self.subscriber.market.accept_offer.assert_called_once_with(
offer_or_id=offer, buyer="mykonos", energy=12)
self.subscriber.redis_db.publish.assert_called_once_with(
"id/ACCEPT_OFFER/RESPONSE",
json.dumps({
"status": "ready",
"trade": trade.to_JSON_string(),
"transaction_uuid": "trans_id"
}))
def accept_offer(self, offer_or_id, buyer, *, energy=None, time=None, already_tracked=False,
trade_rate: float = None, trade_bid_info=None, buyer_origin=None):
offer = offer_or_id
trade = Trade('trade_id', time, offer, offer.seller, buyer,
seller_origin=offer.seller_origin, buyer_origin=buyer_origin)
self.traded_offers.append(trade)
return trade
def test_event_trade_after_offer_changed_partial_offer(area_test2, bus_test2):
original_offer = Offer(id='old_id', price=20, energy=1, seller='FakeArea')
accepted_offer = Offer(id='old_id',
price=15,
energy=0.75,
seller='FakeArea')
residual_offer = Offer(id='res_id',
price=5,
energy=0.25,
seller='FakeArea')
bus_test2.offers.post(original_offer, area_test2.test_market.id)
bus_test2.event_offer_split(market_id=area_test2.test_market.id,
original_offer=original_offer,
accepted_offer=accepted_offer,
residual_offer=residual_offer)
assert original_offer.id in bus_test2.offers.split
assert bus_test2.offers.split[original_offer.id] == accepted_offer
bus_test2.event_trade(market_id=area_test2.test_market.id,
trade=Trade(id='id',
time='time',
offer=original_offer,
seller='FakeArea',
buyer='buyer'))
assert residual_offer in bus_test2.offers.posted
assert bus_test2.offers.posted[residual_offer] == area_test2.test_market.id
assert len(bus_test2.offers.posted) == 1
assert len(bus_test2.offers.split) == 1
assert len(bus_test2.offers.sold) == 1
assert original_offer.id in bus_test2.offers.sold_in_market(
area_test2.test_market.id)
def test_event_bid_traded_removes_bid_from_pending_if_energy_req_0(
load_hours_strategy_test5, market_test2, called):
ConstSettings.IAASettings.MARKET_TYPE = 2
trade_market = load_hours_strategy_test5.area.next_market
load_hours_strategy_test5.remove_bid_from_pending = called
load_hours_strategy_test5.event_activate()
load_hours_strategy_test5.area.markets = {TIME: trade_market}
load_hours_strategy_test5.event_market_cycle()
load_hours_strategy_test5.event_tick()
bid = list(load_hours_strategy_test5._bids.values())[0][0]
# Increase energy requirement to cover the energy from the bid + threshold
load_hours_strategy_test5.energy_requirement_Wh[
TIME] = bid.energy * 1000 + 0.000009
trade = Trade('idt',
None,
bid,
'B',
load_hours_strategy_test5.owner.name,
residual=True)
load_hours_strategy_test5.event_bid_traded(market_id=trade_market.id,
bid_trade=trade)
assert len(load_hours_strategy_test5.remove_bid_from_pending.calls) == 1
assert load_hours_strategy_test5.remove_bid_from_pending.calls[0][0][
0] == repr(bid.id)
assert load_hours_strategy_test5.remove_bid_from_pending.calls[0][0][1] == \
repr(trade_market.id)
def test_publish_event_converts_python_objects_to_json(self):
offer = Offer("1", now(), 2, 3, "A")
trade = Trade("2", now(), Offer("accepted", now(), 7, 8, "Z"), "B",
"C")
new_offer = Offer("3", now(), 4, 5, "D")
existing_offer = Offer("4", now(), 5, 6, "E")
kwargs = {
"offer": offer,
"trade": trade,
"new_offer": new_offer,
"existing_offer": existing_offer
}
for dispatcher in [
self.area.dispatcher.market_event_dispatcher,
self.device1.dispatcher.market_event_dispatcher,
self.device2.dispatcher.market_event_dispatcher
]:
dispatcher.publish_event(dispatcher.area.uuid, MarketEvent.OFFER,
**kwargs)
assert dispatcher.redis.publish.call_count == 1
payload = json.loads(
dispatcher.redis.publish.call_args_list[0][0][1])
assert isinstance(payload["kwargs"]["offer"], str)
assert offer_from_JSON_string(payload["kwargs"]["offer"],
offer.time) == offer
assert isinstance(payload["kwargs"]["trade"], str)
assert trade_from_JSON_string(payload["kwargs"]["trade"],
trade.time) == trade
assert isinstance(payload["kwargs"]["new_offer"], str)
assert offer_from_JSON_string(payload["kwargs"]["new_offer"],
new_offer.time) == new_offer
assert isinstance(payload["kwargs"]["existing_offer"], str)
assert offer_from_JSON_string(payload["kwargs"]["existing_offer"],
existing_offer.time) == \
existing_offer
def accept_offer(self,
offer_or_id,
*,
buyer="",
energy=None,
time=None,
already_tracked=False,
trade_rate: float = None,
trade_bid_info=None,
buyer_origin=None,
buyer_origin_id=None,
buyer_id=None):
offer = offer_or_id
if self.raises:
raise MarketException
else:
if energy is None:
energy = offer.energy
offer.energy = energy
return Trade('trade',
0,
offer,
offer.seller,
'FakeOwner',
seller_origin=offer.seller_origin,
buyer_origin=buyer_origin,
buyer_origin_id=buyer_origin_id,
buyer_id=buyer_id)
def test_balancing_offers_are_created_if_device_in_registry(
balancing_fixture, area_test2):
DeviceRegistry.REGISTRY = {'FakeArea': (30, 40)}
balancing_fixture.event_activate()
balancing_fixture.event_market_cycle()
balancing_fixture.event_balancing_market_cycle()
expected_balancing_demand_energy = \
balancing_fixture.balancing_energy_ratio.demand * \
balancing_fixture.energy_per_slot_Wh
actual_balancing_demand_energy = \
area_test2.test_balancing_market.created_balancing_offers[0].energy
assert len(area_test2.test_balancing_market.created_balancing_offers) == 1
assert actual_balancing_demand_energy == -expected_balancing_demand_energy
actual_balancing_demand_price = \
area_test2.test_balancing_market.created_balancing_offers[0].price
assert actual_balancing_demand_price == expected_balancing_demand_energy * 30
selected_offer = area_test2.current_market.sorted_offers[0]
balancing_fixture.event_trade(market_id=area_test2.current_market.id,
trade=Trade(id='id',
time=area_test2.now,
offer=selected_offer,
seller='B',
buyer='FakeArea'))
assert len(area_test2.test_balancing_market.created_balancing_offers) == 2
actual_balancing_supply_energy = \
area_test2.test_balancing_market.created_balancing_offers[1].energy
expected_balancing_supply_energy = \
selected_offer.energy * balancing_fixture.balancing_energy_ratio.supply
assert actual_balancing_supply_energy == expected_balancing_supply_energy
actual_balancing_supply_price = \
area_test2.test_balancing_market.created_balancing_offers[1].price
assert actual_balancing_supply_price == expected_balancing_supply_energy * 40
DeviceRegistry.REGISTRY = {}
def test_event_trade_after_offer_changed_partial_offer(area_test2,
commercial_test2):
existing_offer = Offer(id='old_id', price=20, energy=1, seller='FakeArea')
new_offer = Offer(id='new_id', price=15, energy=0.75, seller='FakeArea')
commercial_test2.offers.post(existing_offer, area_test2.test_market)
commercial_test2.offers.post(new_offer, area_test2.test_market)
commercial_test2.event_offer_changed(market_id=area_test2.test_market.id,
existing_offer=existing_offer,
new_offer=new_offer)
assert existing_offer.id in commercial_test2.offers.changed
assert commercial_test2.offers.changed[existing_offer.id] == new_offer
commercial_test2.event_trade(market_id=area_test2.test_market.id,
trade=Trade(id='id',
time='time',
offer=existing_offer,
seller='FakeArea',
buyer='buyer'))
assert len(commercial_test2.offers.posted) == 2
assert new_offer in commercial_test2.offers.posted
assert commercial_test2.offers.posted[new_offer] == area_test2.test_market
assert len(commercial_test2.offers.changed) == 0
assert len(commercial_test2.offers.sold) == 1
assert existing_offer.id in commercial_test2.offers.sold[
area_test2.test_market]
def test_event_bid_traded_does_not_remove_bid_for_partial_trade(load_hours_strategy_test5,
called,
partial):
ConstSettings.IAASettings.MARKET_TYPE = 2
trade_market = load_hours_strategy_test5.area.next_market
load_hours_strategy_test5.remove_bid_from_pending = called
load_hours_strategy_test5.event_activate()
load_hours_strategy_test5.area.markets = {TIME: trade_market}
load_hours_strategy_test5.event_market_cycle()
load_hours_strategy_test5.event_tick(area=area_test2)
# Get the bid that was posted on event_market_cycle
bid = list(load_hours_strategy_test5._bids.values())[0][0]
# Increase energy requirement to cover the energy from the bid
load_hours_strategy_test5.energy_requirement_Wh[TIME] = 1000
trade = Trade('idt', None, bid, 'B', load_hours_strategy_test5.owner.name, residual=partial)
load_hours_strategy_test5.event_bid_traded(market_id=trade_market.id, bid_trade=trade)
if not partial:
assert len(load_hours_strategy_test5.remove_bid_from_pending.calls) == 1
assert load_hours_strategy_test5.remove_bid_from_pending.calls[0][0][0] == repr(bid.id)
assert load_hours_strategy_test5.remove_bid_from_pending.calls[0][0][1] == \
repr(trade_market)
else:
assert len(load_hours_strategy_test5.remove_bid_from_pending.calls) == 0
assert load_hours_strategy_test5.get_posted_bids(trade_market) == [bid]
ConstSettings.IAASettings.MARKET_TYPE = 1
def test_dispatch_event_trade_to_external_agent(self, strategy):
strategy._track_energy_sell_type = lambda _: None
self._create_and_activate_strategy_area(strategy)
market = self.area.get_future_market_from_id(1)
self.area._markets.markets = {1: market}
strategy.state.available_energy_kWh = {market.time_slot: 1000.0}
strategy.state.pledged_sell_kWh = {market.time_slot: 0.0}
strategy.state.offered_sell_kWh = {market.time_slot: 0.0}
current_time = now()
trade = Trade('id',
current_time,
Offer('offer_id', now(), 20, 1.0, 'test_area'),
'test_area',
'parent_area',
fee_price=0.23)
strategy.event_trade(market_id="test_market", trade=trade)
assert strategy.redis.publish_json.call_args_list[0][0][
0] == "test_area/events/trade"
call_args = strategy.redis.publish_json.call_args_list[0][0][1]
assert call_args['trade_id'] == trade.id
assert call_args['event'] == "trade"
assert call_args['price'] == 20
assert call_args['energy'] == 1.0
assert call_args['fee_price'] == 0.23
assert call_args['offer_id'] == trade.offer.id
assert call_args['residual_id'] == "None"
assert call_args['time'] == current_time.isoformat()
assert call_args['seller'] == trade.seller
assert call_args['buyer'] == "anonymous"
assert call_args['device_info'] == strategy._device_info_dict
def test_baa_event_trade(baa):
trade = Trade('trade_id', baa.lower_market.time_slot,
Offer('A', 2, 2, 'B'), 'someone_else', 'IAA owner')
fake_spot_market = FakeMarket(15)
fake_spot_market.set_time_slot(baa.lower_market.time_slot)
baa.event_trade(trade=trade, market_id=fake_spot_market.id)
assert baa.lower_market.unmatched_energy_upward == 0
assert baa.lower_market.unmatched_energy_downward == 0
def testing_event_trade(area_test3, pv_test4):
pv_test4.event_trade(market_id=area_test3.test_market.id,
trade=Trade(id='id', time='time',
offer=Offer(id='id', price=20, energy=1, seller='FakeArea'),
seller=area_test3, buyer='buyer'
)
)
assert len(pv_test4.offers.open) == 0
def test_iaa_event_trade_bid_deletes_forwarded_bid_when_sold(iaa_bid, called):
iaa_bid.lower_market.delete_bid = called
iaa_bid.event_bid_traded(bid_trade=Trade('trade_id',
pendulum.now(tz=TIME_ZONE),
iaa_bid.higher_market.bids['id3'],
'someone_else', 'owner'),
market_id=iaa_bid.higher_market.id)
assert len(iaa_bid.lower_market.delete_bid.calls) == 1
def test_assert_if_trade_rate_is_lower_than_offer_rate(pv_test11):
market_id = "market_id"
pv_test11.offers.sold[market_id] = [Offer("offer_id", pendulum.now(), 30, 1, "FakeArea")]
to_cheap_offer = Offer("offer_id", pendulum.now(), 29, 1, "FakeArea")
trade = Trade("trade_id", "time", to_cheap_offer, pv_test11, "buyer")
with pytest.raises(AssertionError):
pv_test11.event_trade(market_id=market_id, trade=trade)
def _trade(price, buyer, energy=1, seller=None, fee_price=None):
return Trade('id',
0,
FakeOffer(price, energy, seller),
seller,
buyer,
None,
fee_price=fee_price)
def test_iaa_event_trade_buys_accepted_offer(iaa2):
iaa2.event_trade(trade=Trade('trade_id',
pendulum.now(tz=TIME_ZONE),
iaa2.higher_market.forwarded_offer,
'owner',
'someone_else'),
market_id=iaa2.higher_market.id)
assert len(iaa2.lower_market.calls_energy) == 1