def test_add_new_region_to_existing_deal_and_calculate_loss(self):
"""
Tests that a new region can be added dynamically to an existing deal for an uncovered event and the loss
can be calculated on the fly
"""
peril = 'fire'
region = 'Porto'
damage = 400
event = Event(peril, region, damage, deals)
if not event.deals_list:
ManageDeals.add_new_deal(250, 250, [
peril,
], [
region,
], deals)
peril = 'fire'
region = 'Lisbon'
damage = 700
event = Event(peril, region, damage, deals)
if not event.deals_list:
ManageDeals.add_region_to_deal('deal4', region, deals)
event.get_applicable_deals(deals)
loss = event.total_loss()
assert loss == 250
def test_calculate_loss_event3(self):
"""
Tests that event3 causes a loss of 250
"""
event = Event('flood', 'Florida', 750, deals)
loss = event.total_loss()
assert loss == 250
def test_calculate_loss_event1(self):
"""
Tests that event1 causes a loss of 500
"""
event = Event('earthquake', 'California', 1000, deals)
loss = event.total_loss()
assert loss == 500
def test_calculate_loss_event4(self):
"""
Tests that event4 causes a loss of 1250. Tests when an event affects more than 1 deal.
"""
event = Event('hurricane', 'Florida', 2000, deals)
loss = event.total_loss()
assert loss == 1250
def test_calculate_loss_event2(self):
"""
Tests that event2 causes a loss of 250
"""
event = Event('flood', 'Louisiana', 500, deals)
loss = event.total_loss()
assert loss == 250
async def set_volume(self, volume):
self.core.bus.dispatch(Event("cec.setting_volume", volume))
running = True if self._target is not None else False
self._target = volume
if not running:
await self.out_queue.put(
Command(CECCommand.get_volume, self._approach_volume)
)
def test_get_applicable_deals_returns_list_with_1_deal(self):
event = Event('flood', 'Louisiana', 500, deals)
event.deals_list = []
event.get_applicable_deals(deals)
self.assertAlmostEqual(event.deals_list,
[{
'retention': 250,
'limit': 250,
'perils': ['hurricane', 'flood'],
'regions': ['Florida', 'Louisiana']
}])
async def prepare(self):
await self.websocket.prepare(self.request)
self.is_open = True
self.core.bus.dispatch(
Event(
NEW_WEBSOCKET_CONNECTION,
{
"id": self.id,
"type": self.connection_type,
"connection": self
},
))
self.core.add_job(self.reader)
await self.writer()
def test_get_applicable_deals_returns_list_with_2_deal(self):
event = Event('hurricane', 'Florida', 2000, deals)
event.deals_list = []
event.get_applicable_deals(deals)
self._baseAssertEqual(event.deals_list,
[{
'regions': ['Florida', 'Louisiana'],
'perils': ['hurricane', 'flood'],
'limit': 250,
'retention': 250
}, {
'regions': ['Florida'],
'perils': ['hurricane'],
'limit': 3000,
'retention': 1000
}])
async def dispatch_event_service(self,
content: Any,
context: Context,
event_type: str = ""):
"""
dispatch an event on the event bus
:param content:
:param context:
:param event_type:
:return:
"""
if context.authorize(BUS, DISPATCH_EVENT):
event = Event(event_type, content, context)
self.dispatch(event)
else:
raise NotAuthorizedError(
f"user {context.user} is not allowed to access the bus",
context, BUS)
async def cio(self):
while True:
with suppress(Exception):
_input = await ainput()
args = _input.split(" ")
if args[0] in ["run", "r"]:
if len(args) == 4:
config = ast.literal_eval(args[3])
else:
config = {}
self.io.run_service(args[1], ast.literal_eval(args[2]),
config, Context.admin())
elif args[0] in ["set", "s"]:
self.registry.call_method_d(f"{args[1]}.set",
ast.literal_eval(args[2]),
Context.admin())
elif args[0] in ["dispatch", "d"]:
self.bus.dispatch(Event(args[1],
ast.literal_eval(args[2])))
def dispatch_state_change_event(
self,
entity: Entity,
component: str,
new_state: Any,
executing_context: Context,
context: Context = None,
):
self.core.bus.dispatch(
Event(
event_type=ENTITY_STATE_CHANGED,
event_content={
"entity": entity,
"component": component,
"new_state": new_state,
"component_type": entity.components[component].type,
"executing_context": executing_context,
},
context=context,
))
def disconnected(self, e):
self.instance.close()
if self.reconnect and not self.silent:
LOGGER.warning(
f"Serial port {self.port} disconnected. Exception: {e}. Trying to reconnect in {self.reconnect_time}"
)
elif not self.silent:
LOGGER.warning(
f"Serial port {self.port} disconnected. Exception: {e}.")
self.core.bus.dispatch(
Event(constants.Events.port_disconnected, {
"port": self.port,
"name": self.name,
"exception": e
}))
if self.reconnect:
self.core.timer.scheduled_call(self.setup,
delay=self.reconnect_time)
async def manager(self, reader, writer: StreamWriter):
self.core.bus.dispatch(
Event(event_type="cec.reconnected", event_content=None, context=None)
)
while True:
try:
done, pending = await asyncio.wait(
[self.out_queue.get(), reader.readline(), self._close_event.wait()],
return_when=asyncio.FIRST_COMPLETED,
loop=self.core.event_loop,
)
except Exception as e:
print(e)
break
try:
gathered = asyncio.gather(*pending)
gathered.cancel()
await gathered
except CancelledError:
pass
result = done.pop().result()
if type(result) is bool:
writer.close()
await writer.wait_closed()
self._closed_event.set()
break
if type(result) is Command:
if type(result.command.value) is list:
for fragment in result.command.value:
writer.write(fragment.encode())
else:
writer.write(result.command.value.encode())
await writer.drain()
if result.callback:
msg = await reader.readline()
await result.callback(msg.decode())
else:
pass
async def _approach_volume(self, new_volume):
if str(new_volume).startswith("51:7a:"):
self.volume = calculate_volume(new_volume)
elif type(new_volume) is str:
await self.out_queue.put(
Command(CECCommand.get_volume, self._approach_volume)
)
return
await asyncio.sleep(0.2)
if self._target < self.volume:
await self.out_queue.put(
Command(CECCommand.decrease_volume, self._approach_volume)
)
elif self._target > self.volume:
await self.out_queue.put(
Command(CECCommand.increase_volume, self._approach_volume)
)
else:
self._target = None
self.core.bus.dispatch(Event("cec.set_volume", self.volume))
async def setup(self, time=None):
try:
self.instance.close()
except:
pass
try:
self.instance.open()
except Exception as e:
if not self.silent:
LOGGER.warning(
f"couldn't open serial port {self.port}! Exceptions {e}")
if self.reconnect:
self.core.timer.scheduled_call(self.setup,
delay=self.reconnect_time)
return
self.__reader = self.core.add_job(self._reader)
self.__writer = self.core.add_job(self._writer)
self.core.bus.dispatch(
Event(constants.Events.port_connected, {
'port': self.port,
'name': self.name
}))
async def gql_dispatch_event(self, *_, eventType="", eventContent=None):
self.core.bus.dispatch(
Event(event_type=eventType, event_content=eventContent))
def test_total_loss_when_damage_higher_then_deal3_limit_and_deal2_limit(
self):
event = Event('hurricane', 'Florida', 5000, deals)
self.assertTrue(event.total_loss() == 3250)
def playback_device_change(device: asp.Device):
return Event(event_type=EVENT_PLAYBACK_DEVICE_CHANGE, event_content=device)
def track_change_event(track: asp.track.FullTrack):
return Event(event_type=EVENT_TRACK_CHANGE, event_content=track)
def playback_started_event(track: asp.track.FullTrack):
return Event(event_type=EVENT_PLAYBACK_STARTED, event_content=track)
def playback_resumed_event(track: asp.track.FullTrack):
return Event(event_type=EVENT_PLAYBACK_RESUMED, event_content=track)
def playback_stopped_event(track: Optional[asp.track.FullTrack]):
return Event(event_type=EVENT_PLAYBACK_STOPPED, event_content=track)
def test_get_applicable_deals_returns_empty_list_when_there_is_no_deal_for_event(
self):
event = Event('hurricane', 'Minnesota', 2000, deals)
event.deals_list = ['dummy data']
event.get_applicable_deals(deals)
self._baseAssertEqual(event.deals_list, [])
def test_total_loss_returns_0_when_no_deal_exists_for_event(self):
event = Event('hurricane', 'Minnesota', 2000, deals)
event.deals_list = []
self.assertTrue(event.total_loss() == 0)
def test_total_loss_returns_0_when_damage_lower_then_retention(self):
event = Event('flood', 'Louisiana', 100, deals)
self.assertTrue(event.total_loss() == 0)
def test_total_loss_lower_then_limit(self):
event = Event('flood', 'Louisiana', 450, deals)
self.assertTrue(event.total_loss() == 200)
def test_total_loss_limited_by_limit(self):
event = Event('flood', 'Louisiana', 450000, deals)
self.assertTrue(event.total_loss() == 250)
def test_total_loss_returns_0_with_several_deals_when_damage_lower_the_retetion(
self):
event = Event('hurricane', 'Florida', 50, deals)
self.assertTrue(event.total_loss() == 0)
def created_event(entity: Entity, user: User):
return Event(
event_type=ENTITY_CREATED,
event_content=entity,
context=Context(user=user, remote=False),
)