def set_time_zone():
"""Set the time zone for the tests."""
# Set our timezone to CST/Regina so we can check calculations
# This keeps UTC-6 all year round
dt_util.set_default_time_zone(dt_util.get_time_zone("America/Regina"))
yield
dt_util.set_default_time_zone(dt_util.get_time_zone("UTC"))
async def test_timezone_intervals(opp):
"""Test date sensor behavior in a timezone besides UTC."""
new_tz = dt_util.get_time_zone("America/New_York")
assert new_tz is not None
dt_util.set_default_time_zone(new_tz)
device = time_date.TimeDateSensor(opp, "date")
now = dt_util.utc_from_timestamp(50000)
with patch("openpeerpower.util.dt.utcnow", return_value=now):
next_time = device.get_next_interval()
# start of local day in EST was 18000.0
# so the second day was 18000 + 86400
assert next_time.timestamp() == 104400
new_tz = dt_util.get_time_zone("America/Edmonton")
assert new_tz is not None
dt_util.set_default_time_zone(new_tz)
now = dt_util.parse_datetime("2017-11-13 19:47:19-07:00")
device = time_date.TimeDateSensor(opp, "date")
with patch("openpeerpower.util.dt.utcnow", return_value=now):
next_time = device.get_next_interval()
assert next_time.timestamp() == dt_util.as_timestamp("2017-11-14 00:00:00-07:00")
# Entering DST
new_tz = dt_util.get_time_zone("Europe/Prague")
assert new_tz is not None
dt_util.set_default_time_zone(new_tz)
now = dt_util.parse_datetime("2020-03-29 00:00+01:00")
with patch("openpeerpower.util.dt.utcnow", return_value=now):
next_time = device.get_next_interval()
assert next_time.timestamp() == dt_util.as_timestamp("2020-03-30 00:00+02:00")
now = dt_util.parse_datetime("2020-03-29 03:00+02:00")
with patch("openpeerpower.util.dt.utcnow", return_value=now):
next_time = device.get_next_interval()
assert next_time.timestamp() == dt_util.as_timestamp("2020-03-30 00:00+02:00")
# Leaving DST
now = dt_util.parse_datetime("2020-10-25 00:00+02:00")
with patch("openpeerpower.util.dt.utcnow", return_value=now):
next_time = device.get_next_interval()
assert next_time.timestamp() == dt_util.as_timestamp("2020-10-26 00:00:00+01:00")
now = dt_util.parse_datetime("2020-10-25 23:59+01:00")
with patch("openpeerpower.util.dt.utcnow", return_value=now):
next_time = device.get_next_interval()
assert next_time.timestamp() == dt_util.as_timestamp("2020-10-26 00:00:00+01:00")
def test_now():
"""Test the now method."""
dt_util.set_default_time_zone(dt_util.get_time_zone(TEST_TIME_ZONE))
assert abs(
dt_util.as_utc(dt_util.now()).replace(tzinfo=None) -
datetime.utcnow()) < timedelta(seconds=1)
def test_set_default_time_zone():
"""Test setting default time zone."""
time_zone = dt_util.get_time_zone(TEST_TIME_ZONE)
dt_util.set_default_time_zone(time_zone)
assert dt_util.now().tzinfo is time_zone
async def test_states_non_default_timezone(opp):
"""Test states of sensors in a timezone other than UTC."""
new_tz = dt_util.get_time_zone("America/New_York")
assert new_tz is not None
dt_util.set_default_time_zone(new_tz)
now = dt_util.utc_from_timestamp(1495068856)
device = time_date.TimeDateSensor(opp, "time")
device._update_internal_state(now)
assert device.state == "20:54"
device = time_date.TimeDateSensor(opp, "date")
device._update_internal_state(now)
assert device.state == "2017-05-17"
device = time_date.TimeDateSensor(opp, "time_utc")
device._update_internal_state(now)
assert device.state == "00:54"
device = time_date.TimeDateSensor(opp, "date_time")
device._update_internal_state(now)
assert device.state == "2017-05-17, 20:54"
device = time_date.TimeDateSensor(opp, "date_time_utc")
device._update_internal_state(now)
assert device.state == "2017-05-18, 00:54"
device = time_date.TimeDateSensor(opp, "beat")
device._update_internal_state(now)
assert device.state == "@079"
device = time_date.TimeDateSensor(opp, "date_time_iso")
device._update_internal_state(now)
assert device.state == "2017-05-17T20:54:00"
def test_auto_purge_disabled(opp_recorder):
"""Test periodic db cleanup still run when auto purge is disabled."""
opp = opp_recorder({CONF_AUTO_PURGE: False})
original_tz = dt_util.DEFAULT_TIME_ZONE
tz = dt_util.get_time_zone("Europe/Copenhagen")
dt_util.set_default_time_zone(tz)
# Purging is scheduled to happen at 4:12am every day. We want
# to verify that when auto purge is disabled perodic db cleanups
# are still scheduled
#
# The clock is started at 4:15am then advanced forward below
now = dt_util.utcnow()
test_time = datetime(now.year + 2, 1, 1, 4, 15, 0, tzinfo=tz)
run_tasks_at_time(opp, test_time)
with patch("openpeerpower.components.recorder.purge.purge_old_data",
return_value=True) as purge_old_data, patch(
"openpeerpower.components.recorder.perodic_db_cleanups"
) as perodic_db_cleanups:
# Advance one day, and the purge task should run
test_time = test_time + timedelta(days=1)
run_tasks_at_time(opp, test_time)
assert len(purge_old_data.mock_calls) == 0
assert len(perodic_db_cleanups.mock_calls) == 1
purge_old_data.reset_mock()
perodic_db_cleanups.reset_mock()
dt_util.set_default_time_zone(original_tz)
def _naive_time_to_utc_datetime(self, naive_time):
"""Convert naive time from config to utc_datetime with current day."""
# get the current local date from utc time
current_local_date = (dt_util.utcnow().astimezone(
dt_util.get_time_zone(self.opp.config.time_zone)).date())
# calculate utc datetime corresponding to local time
return dt_util.as_utc(datetime.combine(current_local_date, naive_time))
def time_zone(value: str) -> str:
"""Validate timezone."""
if dt_util.get_time_zone(value) is not None:
return value
raise vol.Invalid(
"Invalid time zone passed in. Valid options can be found here: "
"http://en.wikipedia.org/wiki/List_of_tz_database_time_zones")
def test_as_utc_with_local_object():
"""Test the UTC time with local object."""
dt_util.set_default_time_zone(dt_util.get_time_zone(TEST_TIME_ZONE))
localnow = dt_util.now()
utcnow = dt_util.as_utc(localnow)
assert localnow == utcnow
assert localnow.tzinfo != utcnow.tzinfo
async def test_timezone_intervals_empty_parameter(opp):
"""Test get_interval() without parameters."""
new_tz = dt_util.get_time_zone("America/Edmonton")
assert new_tz is not None
dt_util.set_default_time_zone(new_tz)
device = time_date.TimeDateSensor(opp, "date")
next_time = device.get_next_interval()
assert next_time.timestamp() == dt_util.as_timestamp("2017-11-14 00:00:00-07:00")
def test_as_local_with_utc_object():
"""Test local time with UTC object."""
dt_util.set_default_time_zone(dt_util.get_time_zone(TEST_TIME_ZONE))
utcnow = dt_util.utcnow()
localnow = dt_util.as_local(utcnow)
assert localnow == utcnow
assert localnow.tzinfo != utcnow.tzinfo
def extra_state_attributes(self):
"""Return the state attributes of the sensor."""
time_zone = dt_util.get_time_zone(self.opp.config.time_zone)
return {
ATTR_AFTER: self._time_after.astimezone(time_zone).isoformat(),
ATTR_BEFORE: self._time_before.astimezone(time_zone).isoformat(),
ATTR_NEXT_UPDATE:
self._next_update.astimezone(time_zone).isoformat(),
}
def set_time_zone(self, time_zone_str: str) -> None:
"""Help to set the time zone."""
time_zone = dt_util.get_time_zone(time_zone_str)
if time_zone:
self.time_zone = time_zone
dt_util.set_default_time_zone(time_zone)
else:
raise ValueError(f"Received invalid time zone {time_zone_str}")
def test_find_next_time_expression_time_dst_chicago():
"""Test daylight saving time for find_next_time_expression_time."""
tz = dt_util.get_time_zone("America/Chicago")
dt_util.set_default_time_zone(tz)
def find(dt, hour, minute, second):
"""Call test_find_next_time_expression_time."""
seconds = dt_util.parse_time_expression(second, 0, 59)
minutes = dt_util.parse_time_expression(minute, 0, 59)
hours = dt_util.parse_time_expression(hour, 0, 23)
return dt_util.find_next_time_expression_time(dt, seconds, minutes,
hours)
# Entering DST, clocks are rolled forward
assert datetime(2021, 3, 15, 2, 30, 0, tzinfo=tz) == find(
datetime(2021, 3, 14, 1, 50, 0, tzinfo=tz), 2, 30, 0)
assert datetime(2021, 3, 15, 2, 30, 0, tzinfo=tz) == find(
datetime(2021, 3, 14, 3, 50, 0, tzinfo=tz), 2, 30, 0)
assert datetime(2021, 3, 15, 2, 30, 0, tzinfo=tz) == find(
datetime(2021, 3, 14, 1, 50, 0, tzinfo=tz), 2, 30, 0)
assert datetime(2021, 3, 14, 3, 30, 0, tzinfo=tz) == find(
datetime(2021, 3, 14, 1, 50, 0, tzinfo=tz), 3, 30, 0)
# Leaving DST, clocks are rolled back
assert datetime(2021, 11, 7, 2, 30, 0, tzinfo=tz, fold=0) == find(
datetime(2021, 11, 7, 2, 5, 0, tzinfo=tz, fold=0), 2, 30, 0)
assert datetime(2021, 11, 7, 2, 30, 0, tzinfo=tz) == find(
datetime(2021, 11, 7, 2, 5, 0, tzinfo=tz), 2, 30, 0)
assert datetime(2021, 11, 7, 2, 30, 0, tzinfo=tz,
fold=0) == find(datetime(2021, 11, 7, 2, 5, 0, tzinfo=tz),
2, 30, 0)
assert datetime(2021, 11, 7, 2, 30, 0, tzinfo=tz,
fold=1) == find(datetime(2021, 11, 7, 2, 10, 0, tzinfo=tz),
2, 30, 0)
assert datetime(2021, 11, 7, 2, 30, 0, tzinfo=tz, fold=1) == find(
datetime(2021, 11, 7, 2, 30, 0, tzinfo=tz, fold=0), 2, 30, 0)
assert datetime(2021, 11, 8, 2, 30, 0, tzinfo=tz, fold=1) == find(
datetime(2021, 11, 7, 2, 55, 0, tzinfo=tz, fold=0), 2, 30, 0)
assert datetime(2021, 11, 7, 4, 30, 0, tzinfo=tz, fold=0) == find(
datetime(2021, 11, 7, 2, 55, 0, tzinfo=tz, fold=1), 4, 30, 0)
assert datetime(2021, 11, 7, 2, 30, 0, tzinfo=tz, fold=1) == find(
datetime(2021, 11, 7, 2, 5, 0, tzinfo=tz, fold=1), 2, 30, 0)
assert datetime(2021, 11, 8, 2, 30, 0, tzinfo=tz) == find(
datetime(2021, 11, 7, 2, 55, 0, tzinfo=tz, fold=0), 2, 30, 0)
def test_auto_purge(opp_recorder):
"""Test periodic purge scheduling."""
opp = opp_recorder()
original_tz = dt_util.DEFAULT_TIME_ZONE
tz = dt_util.get_time_zone("Europe/Copenhagen")
dt_util.set_default_time_zone(tz)
# Purging is scheduled to happen at 4:12am every day. Exercise this behavior by
# firing time changed events and advancing the clock around this time. Pick an
# arbitrary year in the future to avoid boundary conditions relative to the current
# date.
#
# The clock is started at 4:15am then advanced forward below
now = dt_util.utcnow()
test_time = datetime(now.year + 2, 1, 1, 4, 15, 0, tzinfo=tz)
run_tasks_at_time(opp, test_time)
with patch("openpeerpower.components.recorder.purge.purge_old_data",
return_value=True) as purge_old_data, patch(
"openpeerpower.components.recorder.perodic_db_cleanups"
) as perodic_db_cleanups:
# Advance one day, and the purge task should run
test_time = test_time + timedelta(days=1)
run_tasks_at_time(opp, test_time)
assert len(purge_old_data.mock_calls) == 1
assert len(perodic_db_cleanups.mock_calls) == 1
purge_old_data.reset_mock()
perodic_db_cleanups.reset_mock()
# Advance one day, and the purge task should run again
test_time = test_time + timedelta(days=1)
run_tasks_at_time(opp, test_time)
assert len(purge_old_data.mock_calls) == 1
assert len(perodic_db_cleanups.mock_calls) == 1
purge_old_data.reset_mock()
perodic_db_cleanups.reset_mock()
# Advance less than one full day. The alarm should not yet fire.
test_time = test_time + timedelta(hours=23)
run_tasks_at_time(opp, test_time)
assert len(purge_old_data.mock_calls) == 0
assert len(perodic_db_cleanups.mock_calls) == 0
# Advance to the next day and fire the alarm again
test_time = test_time + timedelta(hours=1)
run_tasks_at_time(opp, test_time)
assert len(purge_old_data.mock_calls) == 1
assert len(perodic_db_cleanups.mock_calls) == 1
dt_util.set_default_time_zone(original_tz)
async def test_if_action_after_sunset_no_offset_kotzebue(opp, calls):
"""
Test if action was after sunrise.
Local timezone: Alaska time
Location: Kotzebue, which has a very skewed local timezone with sunrise
at 7 AM and sunset at 3AM during summer
After sunset is true from sunset until midnight, local time.
"""
tz = dt_util.get_time_zone("America/Anchorage")
dt_util.set_default_time_zone(tz)
opp.config.latitude = 66.5
opp.config.longitude = 162.4
await async_setup_component(
opp,
automation.DOMAIN,
{
automation.DOMAIN: {
"trigger": {"platform": "event", "event_type": "test_event"},
"condition": {"condition": "sun", "after": SUN_EVENT_SUNSET},
"action": {"service": "test.automation"},
}
},
)
# sunrise: 2015-07-24 07:17:24 local, sunset: 2015-07-25 03:16:27 local
# sunrise: 2015-07-24 15:17:24 UTC, sunset: 2015-07-25 11:16:27 UTC
# now = sunset -> 'after sunset' true
now = datetime(2015, 7, 25, 11, 16, 27, tzinfo=dt_util.UTC)
with patch("openpeerpower.util.dt.utcnow", return_value=now):
opp.bus.async_fire("test_event")
await opp.async_block_till_done()
assert 1 == len(calls)
# now = sunset - 1s -> 'after sunset' not true
now = datetime(2015, 7, 25, 11, 16, 26, tzinfo=dt_util.UTC)
with patch("openpeerpower.util.dt.utcnow", return_value=now):
opp.bus.async_fire("test_event")
await opp.async_block_till_done()
assert 1 == len(calls)
# now = local midnight -> 'after sunset' not true
now = datetime(2015, 7, 24, 8, 0, 1, tzinfo=dt_util.UTC)
with patch("openpeerpower.util.dt.utcnow", return_value=now):
opp.bus.async_fire("test_event")
await opp.async_block_till_done()
assert 1 == len(calls)
# now = local midnight - 1s -> 'after sunset' true
now = datetime(2015, 7, 24, 7, 59, 59, tzinfo=dt_util.UTC)
with patch("openpeerpower.util.dt.utcnow", return_value=now):
opp.bus.async_fire("test_event")
await opp.async_block_till_done()
assert 2 == len(calls)
async def test_process_timestamp():
"""Test processing time stamp to UTC."""
datetime_with_tzinfo = datetime(2016, 7, 9, 11, 0, 0, tzinfo=dt.UTC)
datetime_without_tzinfo = datetime(2016, 7, 9, 11, 0, 0)
est = dt_util.get_time_zone("US/Eastern")
datetime_est_timezone = datetime(2016, 7, 9, 11, 0, 0, tzinfo=est)
nst = dt_util.get_time_zone("Canada/Newfoundland")
datetime_nst_timezone = datetime(2016, 7, 9, 11, 0, 0, tzinfo=nst)
hst = dt_util.get_time_zone("US/Hawaii")
datetime_hst_timezone = datetime(2016, 7, 9, 11, 0, 0, tzinfo=hst)
assert process_timestamp(datetime_with_tzinfo) == datetime(2016,
7,
9,
11,
0,
0,
tzinfo=dt.UTC)
assert process_timestamp(datetime_without_tzinfo) == datetime(
2016, 7, 9, 11, 0, 0, tzinfo=dt.UTC)
assert process_timestamp(datetime_est_timezone) == datetime(2016,
7,
9,
15,
0,
tzinfo=dt.UTC)
assert process_timestamp(datetime_nst_timezone) == datetime(2016,
7,
9,
13,
30,
tzinfo=dt.UTC)
assert process_timestamp(datetime_hst_timezone) == datetime(2016,
7,
9,
21,
0,
tzinfo=dt.UTC)
assert process_timestamp(None) is None
async def test_process_timestamp_to_utc_isoformat():
"""Test processing time stamp to UTC isoformat."""
datetime_with_tzinfo = datetime(2016, 7, 9, 11, 0, 0, tzinfo=dt.UTC)
datetime_without_tzinfo = datetime(2016, 7, 9, 11, 0, 0)
est = dt_util.get_time_zone("US/Eastern")
datetime_est_timezone = datetime(2016, 7, 9, 11, 0, 0, tzinfo=est)
est = dt_util.get_time_zone("US/Eastern")
datetime_est_timezone = datetime(2016, 7, 9, 11, 0, 0, tzinfo=est)
nst = dt_util.get_time_zone("Canada/Newfoundland")
datetime_nst_timezone = datetime(2016, 7, 9, 11, 0, 0, tzinfo=nst)
hst = dt_util.get_time_zone("US/Hawaii")
datetime_hst_timezone = datetime(2016, 7, 9, 11, 0, 0, tzinfo=hst)
assert (process_timestamp_to_utc_isoformat(datetime_with_tzinfo) ==
"2016-07-09T11:00:00+00:00")
assert (process_timestamp_to_utc_isoformat(datetime_without_tzinfo) ==
"2016-07-09T11:00:00+00:00")
assert (process_timestamp_to_utc_isoformat(datetime_est_timezone) ==
"2016-07-09T15:00:00+00:00")
assert (process_timestamp_to_utc_isoformat(datetime_nst_timezone) ==
"2016-07-09T13:30:00+00:00")
assert (process_timestamp_to_utc_isoformat(datetime_hst_timezone) ==
"2016-07-09T21:00:00+00:00")
assert process_timestamp_to_utc_isoformat(None) is None
def test_auto_statistics(opp_recorder):
"""Test periodic statistics scheduling."""
opp = opp_recorder()
original_tz = dt_util.DEFAULT_TIME_ZONE
tz = dt_util.get_time_zone("Europe/Copenhagen")
dt_util.set_default_time_zone(tz)
# Statistics is scheduled to happen at *:12am every hour. Exercise this behavior by
# firing time changed events and advancing the clock around this time. Pick an
# arbitrary year in the future to avoid boundary conditions relative to the current
# date.
#
# The clock is started at 4:15am then advanced forward below
now = dt_util.utcnow()
test_time = datetime(now.year + 2, 1, 1, 4, 15, 0, tzinfo=tz)
run_tasks_at_time(opp, test_time)
with patch(
"openpeerpower.components.recorder.statistics.compile_statistics",
return_value=True,
) as compile_statistics:
# Advance one hour, and the statistics task should run
test_time = test_time + timedelta(hours=1)
run_tasks_at_time(opp, test_time)
assert len(compile_statistics.mock_calls) == 1
compile_statistics.reset_mock()
# Advance one hour, and the statistics task should run again
test_time = test_time + timedelta(hours=1)
run_tasks_at_time(opp, test_time)
assert len(compile_statistics.mock_calls) == 1
compile_statistics.reset_mock()
# Advance less than one full hour. The task should not run.
test_time = test_time + timedelta(minutes=50)
run_tasks_at_time(opp, test_time)
assert len(compile_statistics.mock_calls) == 0
# Advance to the next hour, and the statistics task should run again
test_time = test_time + timedelta(hours=1)
run_tasks_at_time(opp, test_time)
assert len(compile_statistics.mock_calls) == 1
dt_util.set_default_time_zone(original_tz)
async def async_setup_platform(opp,
config,
async_add_entities,
discovery_info=None):
"""Set up the World clock sensor."""
name = config.get(CONF_NAME)
time_zone = dt_util.get_time_zone(config.get(CONF_TIME_ZONE))
async_add_entities(
[WorldClockSensor(
time_zone,
name,
config.get(CONF_TIME_FORMAT),
)],
True,
)
def test_find_next_time_expression_time_dst():
"""Test daylight saving time for find_next_time_expression_time."""
tz = dt_util.get_time_zone("Europe/Vienna")
dt_util.set_default_time_zone(tz)
def find(dt, hour, minute, second):
"""Call test_find_next_time_expression_time."""
seconds = dt_util.parse_time_expression(second, 0, 59)
minutes = dt_util.parse_time_expression(minute, 0, 59)
hours = dt_util.parse_time_expression(hour, 0, 23)
return dt_util.find_next_time_expression_time(dt, seconds, minutes,
hours)
# Entering DST, clocks are rolled forward
assert datetime(2018, 3, 26, 2, 30, 0, tzinfo=tz) == find(
datetime(2018, 3, 25, 1, 50, 0, tzinfo=tz), 2, 30, 0)
assert datetime(2018, 3, 26, 2, 30, 0, tzinfo=tz) == find(
datetime(2018, 3, 25, 3, 50, 0, tzinfo=tz), 2, 30, 0)
assert datetime(2018, 3, 26, 2, 30, 0, tzinfo=tz) == find(
datetime(2018, 3, 26, 1, 50, 0, tzinfo=tz), 2, 30, 0)
# Leaving DST, clocks are rolled back
assert datetime(2018, 10, 28, 2, 30, 0, tzinfo=tz, fold=0) == find(
datetime(2018, 10, 28, 2, 5, 0, tzinfo=tz, fold=0), 2, 30, 0)
assert datetime(2018, 10, 28, 2, 30, 0, tzinfo=tz,
fold=0) == find(datetime(2018, 10, 28, 2, 5, 0, tzinfo=tz),
2, 30, 0)
assert datetime(2018, 10, 28, 2, 30, 0, tzinfo=tz, fold=1) == find(
datetime(2018, 10, 28, 2, 55, 0, tzinfo=tz), 2, 30, 0)
assert datetime(2018, 10, 28, 2, 30, 0, tzinfo=tz, fold=1) == find(
datetime(2018, 10, 28, 2, 55, 0, tzinfo=tz, fold=0), 2, 30, 0)
assert datetime(2018, 10, 28, 4, 30, 0, tzinfo=tz, fold=0) == find(
datetime(2018, 10, 28, 2, 55, 0, tzinfo=tz, fold=1), 4, 30, 0)
assert datetime(2018, 10, 28, 2, 30, 0, tzinfo=tz, fold=1) == find(
datetime(2018, 10, 28, 2, 5, 0, tzinfo=tz, fold=1), 2, 30, 0)
assert datetime(2018, 10, 28, 2, 30, 0, tzinfo=tz, fold=1) == find(
datetime(2018, 10, 28, 2, 55, 0, tzinfo=tz, fold=0), 2, 30, 0)
async def test_websocket_core_update(opp, client):
"""Test core config update websocket command."""
assert opp.config.latitude != 60
assert opp.config.longitude != 50
assert opp.config.elevation != 25
assert opp.config.location_name != "Huis"
assert opp.config.units.name != CONF_UNIT_SYSTEM_IMPERIAL
assert opp.config.time_zone != "America/New_York"
assert opp.config.external_url != "https://www.example.com"
assert opp.config.internal_url != "http://example.com"
with patch("openpeerpower.util.dt.set_default_time_zone") as mock_set_tz:
await client.send_json(
{
"id": 5,
"type": "config/core/update",
"latitude": 60,
"longitude": 50,
"elevation": 25,
"location_name": "Huis",
CONF_UNIT_SYSTEM: CONF_UNIT_SYSTEM_IMPERIAL,
"time_zone": "America/New_York",
"external_url": "https://www.example.com",
"internal_url": "http://example.local",
}
)
msg = await client.receive_json()
assert msg["id"] == 5
assert msg["type"] == TYPE_RESULT
assert msg["success"]
assert opp.config.latitude == 60
assert opp.config.longitude == 50
assert opp.config.elevation == 25
assert opp.config.location_name == "Huis"
assert opp.config.units.name == CONF_UNIT_SYSTEM_IMPERIAL
assert opp.config.external_url == "https://www.example.com"
assert opp.config.internal_url == "http://example.local"
assert len(mock_set_tz.mock_calls) == 1
assert mock_set_tz.mock_calls[0][1][0] == dt_util.get_time_zone("America/New_York")
def update(self):
"""Update the data for the sensor."""
time_zone = dt_util.get_time_zone(self.opp.config.time_zone)
start = get_date(time_zone)
end = get_date(time_zone, self.days)
try:
res = requests.get(
ENDPOINTS[self.type].format(
self.ssl, self.host, self.port, self.urlbase, start, end
),
headers={"X-Api-Key": self.apikey},
timeout=10,
)
except OSError:
_LOGGER.warning("Host %s is not available", self.host)
self._available = False
self._state = None
return
if res.status_code == HTTP_OK:
if self.type in ["upcoming", "movies", "commands"]:
self.data = res.json()
self._state = len(self.data)
elif self.type == "diskspace":
# If included paths are not provided, use all data
if self.included == []:
self.data = res.json()
else:
# Filter to only show lists that are included
self.data = list(
filter(lambda x: x["path"] in self.included, res.json())
)
self._state = "{:.2f}".format(
to_unit(sum([data["freeSpace"] for data in self.data]), self._unit)
)
elif self.type == "status":
self.data = res.json()
self._state = self.data["version"]
self._available = True
def test_get_time_zone_retrieves_valid_time_zone():
"""Test getting a time zone."""
assert dt_util.get_time_zone(TEST_TIME_ZONE) is not None
MATCH_ALL,
__version__,
)
import openpeerpower.core as ha
from openpeerpower.exceptions import (
InvalidEntityFormatError,
InvalidStateError,
MaxLengthExceeded,
ServiceNotFound,
)
import openpeerpower.util.dt as dt_util
from openpeerpower.util.unit_system import METRIC_SYSTEM
from tests.common import async_capture_events, async_mock_service
PST = dt_util.get_time_zone("America/Los_Angeles")
def test_split_entity_id():
"""Test split_entity_id."""
assert ha.split_entity_id("domain.object_id") == ["domain", "object_id"]
def test_async_add_opp_job_schedule_callback():
"""Test that we schedule coroutines and add jobs to the job pool."""
opp = MagicMock()
job = MagicMock()
ha.OpenPeerPower.async_add_opp_job(opp, ha.OppJob(ha.callback(job)))
assert len(opp.loop.call_soon.mock_calls) == 1
assert len(opp.loop.create_task.mock_calls) == 0
async def test_sensor_availability(opp, caplog, legacy_patchable_time,
pvpc_aioclient_mock: AiohttpClientMocker):
"""Test sensor availability and handling of cloud access."""
opp.config.time_zone = dt_util.get_time_zone("Europe/Madrid")
config = {DOMAIN: [{CONF_NAME: "test_dst", ATTR_TARIFF: "discrimination"}]}
mock_data = {
"return_time": datetime(2019, 10, 27, 20, 0, 0, tzinfo=date_util.UTC)
}
def mock_now():
return mock_data["return_time"]
with patch("openpeerpower.util.dt.utcnow", new=mock_now):
assert await async_setup_component(opp, DOMAIN, config)
await opp.async_block_till_done()
caplog.clear()
assert pvpc_aioclient_mock.call_count == 2
await _process_time_step(opp, mock_data, "price_21h", 0.13896)
await _process_time_step(opp, mock_data, "price_22h", 0.06893)
assert pvpc_aioclient_mock.call_count == 4
await _process_time_step(opp, mock_data, "price_23h", 0.06935)
assert pvpc_aioclient_mock.call_count == 5
# sensor has no more prices, state is "unavailable" from now on
await _process_time_step(opp, mock_data, value="unavailable")
await _process_time_step(opp, mock_data, value="unavailable")
num_errors = sum(1 for x in caplog.records
if x.levelno == logging.ERROR
and "unknown job listener" not in x.msg)
num_warnings = sum(1 for x in caplog.records
if x.levelno == logging.WARNING)
assert num_warnings == 1
assert num_errors == 0
assert pvpc_aioclient_mock.call_count == 9
# check that it is silent until it becomes available again
caplog.clear()
with caplog.at_level(logging.WARNING):
# silent mode
for _ in range(21):
await _process_time_step(opp, mock_data, value="unavailable")
assert pvpc_aioclient_mock.call_count == 30
assert len(caplog.messages) == 0
# warning about data access recovered
await _process_time_step(opp, mock_data, value="unavailable")
assert pvpc_aioclient_mock.call_count == 31
assert len(caplog.messages) == 1
assert caplog.records[0].levelno == logging.WARNING
# working ok again
await _process_time_step(opp,
mock_data,
"price_00h",
value=0.06821)
assert pvpc_aioclient_mock.call_count == 32
await _process_time_step(opp,
mock_data,
"price_01h",
value=0.06627)
assert pvpc_aioclient_mock.call_count == 33
assert len(caplog.messages) == 1
assert caplog.records[0].levelno == logging.WARNING
def test_get_time_zone_returns_none_for_garbage_time_zone():
"""Test getting a non existing time zone."""
assert dt_util.get_time_zone("Non existing time zone") is None
def time_zone():
"""Fixture for time zone."""
return dt_util.get_time_zone("America/New_York")
MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=1)
MAX_LIST = 20
MAX_TIME_OFFSET = 360
ICON = "mdi:bus"
ATTR_DEPARTURE = "departure"
ATTR_LINE = "line"
ATTR_ORIGIN = "origin"
ATTR_DIRECTION = "direction"
ATTR_TYPE = "type"
ATTR_DELAY = "delay"
ATTR_NEXT = "next"
PARALLEL_UPDATES = 0
BERLIN_TIME_ZONE = get_time_zone("Europe/Berlin")
_LOGGER = logging.getLogger(__name__)
async def async_setup_entry(opp, config_entry, async_add_devices):
"""Set up the sensor platform."""
hub = opp.data[DOMAIN][config_entry.entry_id]
session = aiohttp_client.async_get_clientsession(opp)
sensor = HVVDepartureSensor(opp, config_entry, session, hub)
async_add_devices([sensor], True)
class HVVDepartureSensor(SensorEntity):
async def test_timestamp(opp):
"""Test timestamp."""
try:
dt_util.set_default_time_zone(
dt_util.get_time_zone("America/Los_Angeles"))
assert await async_setup_component(
opp,
DOMAIN,
{
DOMAIN: {
"test_datetime_initial_with_tz": {
"has_time": True,
"has_date": True,
"initial": "2020-12-13 10:00:00+01:00",
},
"test_datetime_initial_without_tz": {
"has_time": True,
"has_date": True,
"initial": "2020-12-13 10:00:00",
},
"test_time_initial": {
"has_time": True,
"has_date": False,
"initial": "10:00:00",
},
}
},
)
# initial has been converted to the set timezone
state_with_tz = opp.states.get(
"input_datetime.test_datetime_initial_with_tz")
assert state_with_tz is not None
# Timezone LA is UTC-8 => timestamp carries +01:00 => delta is -9 => 10:00 - 09:00 => 01:00
assert state_with_tz.state == "2020-12-13 01:00:00"
assert (dt_util.as_local(
dt_util.utc_from_timestamp(
state_with_tz.attributes[ATTR_TIMESTAMP])).strftime(
FMT_DATETIME) == "2020-12-13 01:00:00")
# initial has been interpreted as being part of set timezone
state_without_tz = opp.states.get(
"input_datetime.test_datetime_initial_without_tz")
assert state_without_tz is not None
assert state_without_tz.state == "2020-12-13 10:00:00"
# Timezone LA is UTC-8 => timestamp has no zone (= assumed local) => delta to UTC is +8 => 10:00 + 08:00 => 18:00
assert (dt_util.utc_from_timestamp(
state_without_tz.attributes[ATTR_TIMESTAMP]).strftime(FMT_DATETIME)
== "2020-12-13 18:00:00")
assert (dt_util.as_local(
dt_util.utc_from_timestamp(
state_without_tz.attributes[ATTR_TIMESTAMP])).strftime(
FMT_DATETIME) == "2020-12-13 10:00:00")
# Use datetime.datetime.fromtimestamp
assert (dt_util.as_local(
datetime.datetime.fromtimestamp(
state_without_tz.attributes[ATTR_TIMESTAMP],
datetime.timezone.utc)).strftime(FMT_DATETIME) ==
"2020-12-13 10:00:00")
# Test initial time sets timestamp correctly.
state_time = opp.states.get("input_datetime.test_time_initial")
assert state_time is not None
assert state_time.state == "10:00:00"
assert state_time.attributes[ATTR_TIMESTAMP] == 10 * 60 * 60
# Test that setting the timestamp of an entity works.
await opp.services.async_call(
DOMAIN,
"set_datetime",
{
ATTR_ENTITY_ID: "input_datetime.test_datetime_initial_with_tz",
ATTR_TIMESTAMP: state_without_tz.attributes[ATTR_TIMESTAMP],
},
blocking=True,
)
state_with_tz_updated = opp.states.get(
"input_datetime.test_datetime_initial_with_tz")
assert state_with_tz_updated.state == "2020-12-13 10:00:00"
assert (state_with_tz_updated.attributes[ATTR_TIMESTAMP] ==
state_without_tz.attributes[ATTR_TIMESTAMP])
finally:
dt_util.set_default_time_zone(ORIG_TIMEZONE)
