def test_create_trigger_fails_with_wrong_inputs(self):
instance = self.factory(MockHttpClient)
with self.assertRaises(AssertionError):
instance.create_trigger(None,
1527809375, [self._cond1, self._cond2],
[geo.Point(13.6, 46.9)],
alert_channels=None)
with self.assertRaises(AssertionError):
instance.create_trigger(1526809375,
None, [self._cond1, self._cond2],
[geo.Point(13.6, 46.9)],
alert_channels=None)
with self.assertRaises(ValueError):
instance.create_trigger(1526809375,
1327809375, [self._cond1, self._cond2],
[geo.Point(13.6, 46.9)],
alert_channels=None)
with self.assertRaises(AssertionError):
instance.create_trigger(1526809375,
1527809375,
None, [geo.Point(13.6, 46.9)],
alert_channels=None)
with self.assertRaises(ValueError):
instance.create_trigger(1526809375,
1527809375, [], [geo.Point(13.6, 46.9)],
alert_channels=None)
with self.assertRaises(AssertionError):
instance.create_trigger(1526809375,
1527809375, [self._cond1, self._cond2],
None,
alert_channels=None)
with self.assertRaises(ValueError):
instance.create_trigger(1526809375,
1527809375, [self._cond1, self._cond2], [],
alert_channels=None)
def test_multipoint_from_points(self):
expected = geo.MultiPoint([(34, -56.3), (35, 8), (36, 12)])
list_of_points = [
geo.Point(34, -56.3),
geo.Point(35, 8),
geo.Point(36, 12)]
result = geo.MultiPoint.from_points(list_of_points)
self.assertIsInstance(result, geo.MultiPoint)
self.assertEqual(expected.as_dict(), result.as_dict())
def test_polygon_from_points(self):
expected = geo.Polygon([[[2.3, 57.32], [23.19, -20.2], [2.3, 57.32]]])
list_of_lists = [[
geo.Point(2.3, 57.32),
geo.Point(23.19, -20.2),
geo.Point(2.3, 57.32)
]]
result = geo.Polygon.from_points(list_of_lists)
self.assertIsInstance(result, geo.Polygon)
self.assertEqual(expected.to_dict(), result.to_dict())
def test_point_as_dict(self):
expected = {
"coordinates": [34, -56.3],
"type": "Point"
}
point = geo.Point(34, -56.3)
self.assertEqual(expected, point.as_dict())
def test_get_alerts(self):
cond = Condition('humidity', 'LESS_THAN', 10)
alert1 = Alert('alert1', 'trigger1', [{
"current_value": 263.576,
"condition": cond
}], {
"lon": 37,
"lat": 53
}, 1481802090232)
alert2 = Alert('alert2', 'trigger1', [{
"current_value": 111.576,
"condition": cond
}], {
"lon": 37,
"lat": 53
}, 1481802100000)
alerts = [alert1, alert2]
instance = Trigger(1526809375,
1527809375, [cond], [geo.Point(13.6, 46.9)],
alerts=alerts,
alert_channels=None)
result = instance.get_alerts()
self.assertTrue(isinstance(result, list))
self.assertTrue(alert1 in result)
self.assertTrue(alert2 in result)
def test_bulding_points(self):
the_dict = {"coordinates": [34, -56.3], "type": "Point"}
expected = geo.Point(34, -56.3)
result = geo.GeometryBuilder.build(the_dict)
self.assertIsInstance(result, geo.Point)
self.assertEqual(expected.lat, result.lat)
self.assertEqual(expected.lon, result.lon)
def test_point_from_dict(self):
the_dict = {"coordinates": [34, -56.3], "type": "Point"}
expected = geo.Point(34, -56.3)
result = geo.Point.from_dict(the_dict)
self.assertIsInstance(result, geo.Point)
self.assertEqual(expected.lat, result.lat)
self.assertEqual(expected.lon, result.lon)
def test_to_dict(self):
cond = Condition('humidity', 'LESS_THAN', 10)
instance = Trigger(1526809375,
1527809375, [cond], [geo.Point(13.6, 46.9)],
alerts=[],
alert_channels=None,
id='myid')
result = instance.to_dict()
self.assertIsInstance(result, dict)
self.assertEqual('myid', result['id'])
self.assertEqual(1526809375, result['start_after_millis'])
self.assertEqual(1527809375, result['end_after_millis'])
self.assertEqual([dict(name='OWM API POLLING')],
result['alert_channels'])
self.assertEqual(list(), result['alerts'])
self.assertEqual([{
'type': 'Point',
'coordinates': [13.6, 46.9]
}], result['area'])
self.assertEqual([{
'id': None,
'weather_param': 'humidity',
'operator': 'LESS_THAN',
'amount': 10
}], result['conditions'])
def test_point_geojson(self):
expected = {
"coordinates": [34, -56.3],
"type": "Point"
}
point = geo.Point(34, -56.3)
self.assertEqual(sorted(json.dumps(expected)),
sorted(point.geojson()))
def test_create_trigger(self):
instance = self.factory(MockHttpClient)
result = instance.create_trigger(1526809375,
1527809375,
[self._cond1, self._cond2],
[geo.Point(13.6, 46.9)],
alert_channels=None)
self.assertIsInstance(result, Trigger)
def test_repr(self):
instance = Trigger(1526809375,
1527809375,
[Condition('humidity', 'LESS_THAN', 10)],
[geo.Point(13.6, 46.9)],
alerts=None,
alert_channels=None)
print(instance)
def test_init(self):
alert_channels = [AlertChannelsEnum.items()]
instance = Trigger(1526809375,
1527809375,
[Condition('humidity', 'LESS_THAN', 10)],
[geo.Point(13.6, 46.9)],
alerts=None,
alert_channels=alert_channels)
self.assertEqual(instance.alert_channels, alert_channels)
def to_geopoint(self):
"""
Returns the geoJSON compliant representation of the place for this One Call
:returns: a ``pyowm.utils.geo.Point`` instance
"""
if self.lon is None or self.lat is None:
return None
return geo.Point(self.lon, self.lat)
def test_defaulted_parameters(self):
instance = Trigger(1526809375,
1527809375,
[Condition('humidity', 'LESS_THAN', 10)],
[geo.Point(13.6, 46.9)],
alerts=None,
alert_channels=None)
self.assertIsInstance(instance.alerts, list)
self.assertEqual(0, len(instance.alerts))
self.assertIsInstance(instance.alert_channels, list)
self.assertEqual(1, len(instance.alert_channels))
self.assertEqual(instance.alert_channels[0],
AlertChannelsEnum.OWM_API_POLLING)
def test_get_alerts_since(self):
cond = Condition('humidity', 'LESS_THAN', 10)
alert1 = Alert('alert1', 'trigger1', [{
"current_value": 263.576,
"condition": cond
}], {
"lon": 37,
"lat": 53
}, 1000)
alert2 = Alert('alert2', 'trigger1', [{
"current_value": 111.576,
"condition": cond
}], {
"lon": 37,
"lat": 53
}, 3000)
alert3 = Alert('alert3', 'trigger1', [{
"current_value": 119.332,
"condition": cond
}], {
"lon": 37,
"lat": 53
}, 9000)
alert4 = Alert('alert4', 'trigger1', [{
"current_value": 119.332,
"condition": cond
}], {
"lon": 37,
"lat": 53
}, 12000)
alerts = [alert1, alert2, alert3, alert4]
instance = Trigger(1526809375,
1527809375, [cond], [geo.Point(13.6, 46.9)],
alerts=alerts,
alert_channels=None)
result = instance.get_alerts_since(4000)
self.assertEqual(2, len(result))
self.assertTrue(alert3 in result)
self.assertTrue(alert4 in result)
result = instance.get_alerts_since(3000)
self.assertEqual(3, len(result))
self.assertTrue(alert2 in result)
self.assertTrue(alert3 in result)
self.assertTrue(alert4 in result)
result = instance.get_alerts_since(15000)
self.assertEqual(0, len(result))
def test_get_alert(self):
cond = Condition('humidity', 'LESS_THAN', 10)
alert = Alert('alert1', 'trigger1', [{
"current_value": 263.576,
"condition": cond
}], {
"lon": 37,
"lat": 53
}, 1481802090232)
alerts = [alert]
instance = Trigger(1526809375,
1527809375, [cond], [geo.Point(13.6, 46.9)],
alerts=alerts,
alert_channels=None)
self.assertEqual(alert, instance.get_alert('alert1'))
def test_get_alerts_on(self):
cond1 = Condition('humidity', 'LESS_THAN', 10)
cond2 = Condition('temp', 'GREATER_THAN_EQUAL', 100.6)
alert1 = Alert('alert1', 'trigger1', [{
"current_value": 8.576,
"condition": cond1
}], {
"lon": 37,
"lat": 53
}, 1000)
alert2 = Alert('alert2', 'trigger1', [{
"current_value": 111.576,
"condition": cond2
}], {
"lon": 37,
"lat": 53
}, 3000)
alert3 = Alert('alert3', 'trigger1', [{
"current_value": 119.332,
"condition": cond2
}], {
"lon": 37,
"lat": 53
}, 9000)
alert4 = Alert('alert4', 'trigger1', [{
"current_value": 7.332,
"condition": cond1
}], {
"lon": 37,
"lat": 53
}, 12000)
alerts = [alert1, alert2, alert3, alert4]
instance = Trigger(1526809375,
1527809375, [cond1, cond2], [geo.Point(13.6, 46.9)],
alerts=alerts,
alert_channels=None)
result = instance.get_alerts_on('temp')
self.assertEqual(2, len(result))
self.assertTrue(alert2 in result)
self.assertTrue(alert3 in result)
result = instance.get_alerts_on('humidity')
self.assertEqual(2, len(result))
self.assertTrue(alert1 in result)
self.assertTrue(alert4 in result)
result = instance.get_alerts_on('wind_direction')
self.assertEqual(0, len(result))
def test_get_alert(self):
cond = Condition('humidity', 'LESS_THAN', 10)
alert = Alert('alert1', 'trigger1', [{
"current_value": 263.576,
"condition": cond
}], {
"lon": 37,
"lat": 53
}, 1481802090232)
alert_two = copy.deepcopy(alert)
alert_two.id = 'alert_two'
alerts = [alert_two, alert
] # Second alert has to be 1st element to have full coverage
instance = Trigger(1526809375,
1527809375, [cond], [geo.Point(13.6, 46.9)],
alerts=alerts,
alert_channels=None)
self.assertEqual(alert, instance.get_alert('alert1'))
# Trigger without alerts
instance.alerts = []
self.assertIsNone(instance.get_alert(alert_id='alert1'))
def weather_alerts(owm_api, lat, lng):
owm_obj = OWM(owm_api)
am = owm_obj.alert_manager()
# available types: Point, MultiPoint, Polygon, MultiPolygon
geom_1 = geo.Point(lng, lat)
# TBD: Alert should be cast over a wide area.
# Alerts will have far reaching effects.
#geom_1.geojson()
#'''
#{
# "type": "Point",
# "coordinates":[ lon, lat ]
#}
#'''
# Pune - Mumbai - Satara - Pune
# Indore - Nagpur - Hyderabad - Indore
#geom_2 = geo.MultiPolygon([[73.856743, 18.520430], [72.877655, 19.075983]])
# -- conditions --
condition_1 = Condition(WeatherParametersEnum.TEMPERATURE,
OperatorsEnum.GREATER_THAN,
310.15) # kelvin, 35C
condition_2 = Condition(WeatherParametersEnum.CLOUDS,
OperatorsEnum.GREATER_THAN,
60) # clouds % coverage
# create a trigger
trigger = am.create_trigger(start_after_millis=355000, end_after_millis=487000,\
conditions=[condition_1, condition_2],\
area=[geom_1],\
alert_channel=AlertChannelsEnum.OWM_API_POLLING)
# read all triggers
triggers_list = am.get_triggers()
print("Read all Weather triggers: {}".format(triggers_list))
class TestAlertManager(unittest.TestCase):
_cond1 = Condition('humidity', 'LESS_THAN', 10)
_cond2 = Condition('temp', 'GREATER_THAN_EQUAL', 100.6)
_trigger = Trigger(1526809375,
1527809375, [_cond1, _cond2], [geo.Point(13.6, 46.9)],
alerts=[],
alert_channels=None,
id='trigger-id')
_alert = Alert('alert1', 'trigger1', [{
"current_value": 263.576,
"condition": _cond1
}], {
"lon": 37,
"lat": 53
}, 1481802090232)
def factory(self, _kls):
sm = AlertManager('APIKey')
sm.http_client = _kls()
return sm
def test_instantiation_fails_without_api_key(self):
self.assertRaises(AssertionError, AlertManager, None)
def test_get_alert_api_version(self):
instance = AlertManager('APIKey')
result = instance.alert_api_version()
self.assertIsInstance(result, tuple)
self.assertEqual(result, ALERT_API_VERSION)
def test_get_triggers(self):
instance = self.factory(MockHttpClientTwoTriggers)
results = instance.get_triggers()
self.assertEqual(2, len(results))
t = results[0]
self.assertIsInstance(t, Trigger)
def test_get_trigger_fails_with_wrong_input(self):
instance = AlertManager('APIKey')
with self.assertRaises(AssertionError):
instance.get_trigger(None)
with self.assertRaises(AssertionError):
instance.get_trigger(123)
def test_get_trigger(self):
instance = self.factory(MockHttpClientOneTrigger)
result = instance.get_trigger('any-id')
self.assertIsInstance(result, Trigger)
def test_create_trigger(self):
instance = self.factory(MockHttpClient)
result = instance.create_trigger(1526809375,
1527809375,
[self._cond1, self._cond2],
[geo.Point(13.6, 46.9)],
alert_channels=None)
self.assertIsInstance(result, Trigger)
def test_create_trigger_fails_with_wrong_inputs(self):
instance = self.factory(MockHttpClient)
with self.assertRaises(AssertionError):
instance.create_trigger(None,
1527809375, [self._cond1, self._cond2],
[geo.Point(13.6, 46.9)],
alert_channels=None)
with self.assertRaises(AssertionError):
instance.create_trigger(1526809375,
None, [self._cond1, self._cond2],
[geo.Point(13.6, 46.9)],
alert_channels=None)
with self.assertRaises(ValueError):
instance.create_trigger(1526809375,
1327809375, [self._cond1, self._cond2],
[geo.Point(13.6, 46.9)],
alert_channels=None)
with self.assertRaises(AssertionError):
instance.create_trigger(1526809375,
1527809375,
None, [geo.Point(13.6, 46.9)],
alert_channels=None)
with self.assertRaises(ValueError):
instance.create_trigger(1526809375,
1527809375, [], [geo.Point(13.6, 46.9)],
alert_channels=None)
with self.assertRaises(AssertionError):
instance.create_trigger(1526809375,
1527809375, [self._cond1, self._cond2],
None,
alert_channels=None)
with self.assertRaises(ValueError):
instance.create_trigger(1526809375,
1527809375, [self._cond1, self._cond2], [],
alert_channels=None)
def test_delete_trigger_fails_with_wrong_input(self):
instance = AlertManager('APIKey')
with self.assertRaises(AssertionError):
instance.delete_trigger(None)
with self.assertRaises(AssertionError):
self._trigger.id = 123
instance.delete_trigger(self._trigger)
def test_delete_trigger(self):
instance = self.factory(MockHttpClient)
parser = TriggerParser()
trigger = parser.parse_JSON(MockHttpClient.test_trigger_json)
result = instance.delete_trigger(trigger)
self.assertIsNone(result)
def test_update_trigger_fails_with_wrong_input(self):
instance = AlertManager('APIKey')
with self.assertRaises(AssertionError):
instance.update_trigger(None)
with self.assertRaises(AssertionError):
self._trigger.id = 123
instance.update_trigger(self._trigger)
def test_update_trigger(self):
instance = self.factory(MockHttpClient)
parser = TriggerParser()
modified_trigger = parser.parse_JSON(MockHttpClient.test_trigger_json)
modified_trigger.id = '5852816a9aaacb00153134a3'
modified_trigger.end = self._trigger.end_after_millis + 10000
result = instance.update_trigger(modified_trigger)
self.assertIsNone(result)
def test_get_alerts_for_fails_with_wrong_input(self):
instance = AlertManager('APIKey')
with self.assertRaises(AssertionError):
instance.get_alerts_for(None)
with self.assertRaises(AssertionError):
self._trigger.id = 123
instance.get_alerts_for(self._trigger)
def test_get_alerts_for(self):
instance = self.factory(MockHttpClientTwoAlerts)
self._trigger.id = 'trigger-id'
results = instance.get_alerts_for(self._trigger)
self.assertEqual(2, len(results))
self.assertIsInstance(results[0], Alert)
self.assertIsInstance(results[1], Alert)
def test_get_alert_fails_with_wrong_input(self):
instance = AlertManager('APIKey')
with self.assertRaises(AssertionError):
instance.get_alert(None, self._trigger)
with self.assertRaises(AssertionError):
instance.get_alert(123, self._trigger)
with self.assertRaises(AssertionError):
instance.get_alert('alert-id', None)
with self.assertRaises(AssertionError):
self._trigger.id = 123
instance.get_alert('alert-id', self._trigger)
def test_get_alert(self):
self._trigger.id = 'trigger-id'
instance = self.factory(MockHttpClientOneAlert)
result = instance.get_alert('alert-id', self._trigger)
self.assertIsInstance(result, Alert)
def test_delete_all_alerts_for_fails_with_wrong_input(self):
instance = AlertManager('APIKey')
with self.assertRaises(AssertionError):
instance.delete_all_alerts_for(None)
with self.assertRaises(AssertionError):
self._trigger.id = 123
instance.delete_all_alerts_for(self._trigger)
def test_delete_all_alerts_for(self):
instance = self.factory(MockHttpClientTwoAlerts)
result = instance.delete_all_alerts_for(self._trigger)
self.assertIsNone(result)
def test_delete_alert_fails_with_wrong_input(self):
instance = AlertManager('APIKey')
with self.assertRaises(AssertionError):
instance.delete_alert(None)
with self.assertRaises(AssertionError):
self._alert.id = 123
instance.delete_alert(self._alert)
self._alert.id = 'alert-id'
self._alert.trigger_id = None
with self.assertRaises(AssertionError):
instance.delete_alert(self._alert)
self._alert.trigger_id = 789
with self.assertRaises(AssertionError):
instance.delete_alert(self._alert)
def test_delete_alert(self):
instance = self.factory(MockHttpClientOneAlert)
result = instance.delete_alert(self._alert)
self.assertIsNone(result)
def test_point_properties(self):
lon = -56.3
lat = 34
point = geo.Point(lon, lat)
self.assertEqual(lon, point.lon)
self.assertEqual(lat, point.lat)
def test_trigger_fails_with_wrong_parameters(self):
start_after_millis = 450000
end_after_millis = 470000
conditions = [Condition('humidity', 'LESS_THAN', 10)]
area = [geo.Point(13.6, 46.9)]
self.assertRaises(AssertionError,
Trigger,
None,
end_after_millis,
conditions,
area,
alerts=None,
alert_channels=None,
id=None)
self.assertRaises(AssertionError,
Trigger,
start_after_millis,
None,
conditions,
area,
alerts=None,
alert_channels=None,
id=None)
self.assertRaises(AssertionError,
Trigger,
'test',
end_after_millis,
conditions,
area,
alerts=None,
alert_channels=None,
id=None)
self.assertRaises(AssertionError,
Trigger,
start_after_millis,
'test',
conditions,
area,
alerts=None,
alert_channels=None,
id=None)
self.assertRaises(ValueError,
Trigger,
end_after_millis,
start_after_millis,
conditions,
area,
alerts=None,
alert_channels=None,
id=None)
self.assertRaises(AssertionError,
Trigger,
start_after_millis,
end_after_millis,
None,
area,
alerts=None,
alert_channels=None,
id=None)
self.assertRaises(ValueError,
Trigger,
start_after_millis,
end_after_millis, [],
area,
alerts=None,
alert_channels=None,
id=None)
self.assertRaises(AssertionError,
Trigger,
start_after_millis,
end_after_millis,
conditions,
None,
alerts=None,
alert_channels=None,
id=None)
self.assertRaises(ValueError,
Trigger,
start_after_millis,
end_after_millis,
conditions, [],
alerts=None,
alert_channels=None,
id=None)
_ = Trigger(start_after_millis,
end_after_millis,
conditions,
area,
alerts=None,
alert_channels=None)
