def setUp(self): """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant() # 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'))
def test_periodic_task_leaving_dst(self): """Test periodic task behavior when leaving dst.""" tz = dt_util.get_time_zone('Europe/Vienna') dt_util.set_default_time_zone(tz) specific_runs = [] unsub = track_time_change( self.hass, lambda x: specific_runs.append(1), hour=2, minute=30, second=0) self._send_time_changed( tz.localize(datetime(2018, 10, 28, 2, 5, 0), is_dst=False)) self.hass.block_till_done() assert 0 == len(specific_runs) self._send_time_changed( tz.localize(datetime(2018, 10, 28, 2, 55, 0), is_dst=False)) self.hass.block_till_done() assert 1 == len(specific_runs) self._send_time_changed( tz.localize(datetime(2018, 10, 28, 2, 5, 0), is_dst=True)) self.hass.block_till_done() assert 1 == len(specific_runs) self._send_time_changed( tz.localize(datetime(2018, 10, 28, 2, 55, 0), is_dst=True)) self.hass.block_till_done() assert 2 == len(specific_runs) unsub()
def test_set_default_time_zone(self): """Test setting default time zone.""" time_zone = dt_util.get_time_zone(TEST_TIME_ZONE) dt_util.set_default_time_zone(time_zone) # We cannot compare the timezones directly because of DST assert time_zone.zone == dt_util.now().tzinfo.zone
def test_as_utc_with_local_object(self): """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
def test_now(self): """Test the now method.""" dt_util.set_default_time_zone(dt_util.get_time_zone(TEST_TIME_ZONE)) self.assertAlmostEqual( dt_util.as_utc(dt_util.now()).replace(tzinfo=None), datetime.utcnow(), delta=timedelta(seconds=1))
def test_as_local_with_utc_object(self): dt_util.set_default_time_zone(dt_util.get_time_zone(TEST_TIME_ZONE)) utcnow = dt_util.utcnow() localnow = dt_util.as_local(utcnow) self.assertEqual(localnow, utcnow) self.assertNotEqual(localnow.tzinfo, utcnow.tzinfo)
def test_timezone_intervals_empty_parameter(self, _): """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(self.hass, '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_now(self): """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_as_local_with_utc_object(self): """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 set_time_zone(time_zone_str: Optional[str]) -> None: """Help to set the time zone.""" if time_zone_str is None: return time_zone = date_util.get_time_zone(time_zone_str) if time_zone: hac.time_zone = time_zone date_util.set_default_time_zone(time_zone) else: _LOGGER.error("Received invalid time zone %s", time_zone_str)
def test_timezone_intervals(self): """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(self.hass, 'date') now = dt_util.utc_from_timestamp(50000) next_time = device.get_next_interval(now) # start of local day in EST was 18000.0 # so the second day was 18000 + 86400 assert next_time.timestamp() == 104400
def set_time_zone(time_zone_str): """ Helper method to set time zone in HA. """ if time_zone_str is None: return time_zone = date_util.get_time_zone(time_zone_str) if time_zone: hac.time_zone = time_zone date_util.set_default_time_zone(time_zone) else: _LOGGER.error("Received invalid time zone %s", time_zone_str)
def test_jewish_calendar_sensor(self, time, tzname, latitude, longitude, language, sensor, diaspora, result): """Test Jewish calendar sensor output.""" tz = get_time_zone(tzname) set_default_time_zone(tz) test_time = tz.localize(time) self.hass.config.latitude = latitude self.hass.config.longitude = longitude sensor = JewishCalSensor( name='test', language=language, sensor_type=sensor, latitude=latitude, longitude=longitude, timezone=tz, diaspora=diaspora) sensor.hass = self.hass with patch('homeassistant.util.dt.now', return_value=test_time): run_coroutine_threadsafe( sensor.async_update(), self.hass.loop).result() assert sensor.state == result
def test_find_next_time_expression_time_dst(self): """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 tz.localize(datetime(2018, 3, 26, 2, 30, 0)) == \ find(tz.localize(datetime(2018, 3, 25, 1, 50, 0)), 2, 30, 0) assert tz.localize(datetime(2018, 3, 26, 2, 30, 0)) == \ find(tz.localize(datetime(2018, 3, 25, 3, 50, 0)), 2, 30, 0) assert tz.localize(datetime(2018, 3, 26, 2, 30, 0)) == \ find(tz.localize(datetime(2018, 3, 26, 1, 50, 0)), 2, 30, 0) # Leaving DST, clocks are rolled back assert tz.localize(datetime(2018, 10, 28, 2, 30, 0), is_dst=False) == \ find(tz.localize(datetime(2018, 10, 28, 2, 5, 0), is_dst=False), 2, 30, 0) assert tz.localize(datetime(2018, 10, 28, 2, 30, 0), is_dst=False) == \ find(tz.localize(datetime(2018, 10, 28, 2, 55, 0), is_dst=True), 2, 30, 0) assert tz.localize(datetime(2018, 10, 28, 4, 30, 0), is_dst=False) == \ find(tz.localize(datetime(2018, 10, 28, 2, 55, 0), is_dst=True), 4, 30, 0) assert tz.localize(datetime(2018, 10, 28, 2, 30, 0), is_dst=True) == \ find(tz.localize(datetime(2018, 10, 28, 2, 5, 0), is_dst=True), 2, 30, 0) assert tz.localize(datetime(2018, 10, 29, 2, 30, 0)) == \ find(tz.localize(datetime(2018, 10, 28, 2, 55, 0), is_dst=False), 2, 30, 0)
def test_issur_melacha_sensor(self, now, candle_lighting, havdalah, diaspora, tzname, latitude, longitude, result): """Test Issur Melacha sensor output.""" time_zone = get_time_zone(tzname) set_default_time_zone(time_zone) test_time = time_zone.localize(now) self.hass.config.latitude = latitude self.hass.config.longitude = longitude sensor = JewishCalSensor( name='test', language='english', sensor_type='issur_melacha_in_effect', latitude=latitude, longitude=longitude, timezone=time_zone, diaspora=diaspora, havdalah_offset=havdalah, candle_lighting_offset=candle_lighting) sensor.hass = self.hass with patch('homeassistant.util.dt.now', return_value=test_time): run_coroutine_threadsafe( sensor.async_update(), self.hass.loop).result() assert sensor.state == result
def test_shabbat_times_sensor(self, now, candle_lighting, havdalah, diaspora, tzname, latitude, longitude, result): """Test sensor output for upcoming shabbat/yomtov times.""" time_zone = get_time_zone(tzname) set_default_time_zone(time_zone) test_time = time_zone.localize(now) for sensor_type, value in result.items(): if isinstance(value, dt): result[sensor_type] = time_zone.localize(value) self.hass.config.latitude = latitude self.hass.config.longitude = longitude if ('upcoming_shabbat_candle_lighting' in result and 'upcoming_candle_lighting' not in result): result['upcoming_candle_lighting'] = \ result['upcoming_shabbat_candle_lighting'] if ('upcoming_shabbat_havdalah' in result and 'upcoming_havdalah' not in result): result['upcoming_havdalah'] = result['upcoming_shabbat_havdalah'] for sensor_type, result_value in result.items(): language = 'english' if sensor_type.startswith('hebrew_'): language = 'hebrew' sensor_type = sensor_type.replace('hebrew_', '') sensor = JewishCalSensor( name='test', language=language, sensor_type=sensor_type, latitude=latitude, longitude=longitude, timezone=time_zone, diaspora=diaspora, havdalah_offset=havdalah, candle_lighting_offset=candle_lighting) sensor.hass = self.hass with patch('homeassistant.util.dt.now', return_value=test_time): run_coroutine_threadsafe( sensor.async_update(), self.hass.loop).result() assert sensor.state == result_value, "Value for {}".format( sensor_type)
def test_find_next_time_expression_time_leave_dst_chicago_into_the_fold_same_time(): """Test leaving daylight saving time for find_next_time_expression_time.""" tz = dt_util.get_time_zone("America/Chicago") dt_util.set_default_time_zone(tz) # Leaving DST, clocks are rolled back # Find the same time inside the fold hour_minute_second = (1, 30, 1) test_time = datetime(2021, 11, 7, *hour_minute_second, tzinfo=tz, fold=0) matching_hours, matching_minutes, matching_seconds = _get_matches( *hour_minute_second ) next_time = dt_util.find_next_time_expression_time( test_time, matching_seconds, matching_minutes, matching_hours ) assert next_time == datetime(2021, 11, 7, *hour_minute_second, tzinfo=tz, fold=1) assert next_time.fold == 0 assert dt_util.as_utc(next_time) == datetime( 2021, 11, 7, 6, 30, 1, tzinfo=dt_util.UTC )
async def test_websocket_core_update(hass, client): """Test core config update websocket command.""" assert hass.config.latitude != 60 assert hass.config.longitude != 50 assert hass.config.elevation != 25 assert hass.config.location_name != "Huis" assert hass.config.units.name != CONF_UNIT_SYSTEM_IMPERIAL assert hass.config.time_zone.zone != "America/New_York" assert hass.config.external_url != "https://www.example.com" assert hass.config.internal_url != "http://example.com" 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 hass.config.latitude == 60 assert hass.config.longitude == 50 assert hass.config.elevation == 25 assert hass.config.location_name == "Huis" assert hass.config.units.name == CONF_UNIT_SYSTEM_IMPERIAL assert hass.config.time_zone.zone == "America/New_York" assert hass.config.external_url == "https://www.example.com" assert hass.config.internal_url == "http://example.local" dt_util.set_default_time_zone(ORIG_TIME_ZONE)
def test_timezone_intervals(self): """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(self.hass, "date") now = dt_util.utc_from_timestamp(50000) next_time = device.get_next_interval(now) # 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(self.hass, "date") next_time = device.get_next_interval(now) assert next_time.timestamp() == dt_util.as_timestamp( "2017-11-14 00:00:00-07:00" )
def test_auto_purge(hass_recorder): """Test saving and restoring a state.""" hass = hass_recorder() original_tz = dt_util.DEFAULT_TIME_ZONE tz = dt_util.get_time_zone("Europe/Copenhagen") dt_util.set_default_time_zone(tz) test_time = tz.localize(datetime(2020, 1, 1, 4, 12, 0)) with patch("homeassistant.components.recorder.purge.purge_old_data" ) as purge_old_data: for delta in (-1, 0, 1): hass.bus.fire(EVENT_TIME_CHANGED, {ATTR_NOW: test_time + timedelta(seconds=delta)}) hass.block_till_done() hass.data[DATA_INSTANCE].block_till_done() assert len(purge_old_data.mock_calls) == 1 dt_util.set_default_time_zone(original_tz)
def test_jewish_calendar_sensor(self, cur_time, tzname, latitude, longitude, language, sensor, diaspora, result): """Test Jewish calendar sensor output.""" time_zone = get_time_zone(tzname) set_default_time_zone(time_zone) test_time = time_zone.localize(cur_time) self.hass.config.latitude = latitude self.hass.config.longitude = longitude sensor = JewishCalSensor( name="test", language=language, sensor_type=sensor, latitude=latitude, longitude=longitude, timezone=time_zone, diaspora=diaspora, ) sensor.hass = self.hass with patch("homeassistant.util.dt.now", return_value=test_time): run_coroutine_threadsafe(sensor.async_update(), self.hass.loop).result() assert sensor.state == result
def test_issur_melacha_sensor(self, now, candle_lighting, havdalah, diaspora, tzname, latitude, longitude, result): """Test Issur Melacha sensor output.""" time_zone = get_time_zone(tzname) set_default_time_zone(time_zone) test_time = time_zone.localize(now) self.hass.config.latitude = latitude self.hass.config.longitude = longitude sensor = JewishCalSensor(name='test', language='english', sensor_type='issur_melacha_in_effect', latitude=latitude, longitude=longitude, timezone=time_zone, diaspora=diaspora, havdalah_offset=havdalah, candle_lighting_offset=candle_lighting) sensor.hass = self.hass with patch('homeassistant.util.dt.now', return_value=test_time): run_coroutine_threadsafe(sensor.async_update(), self.hass.loop).result() assert sensor.state == result
def test_auto_purge(hass_recorder): """Test saving and restoring a state.""" hass = hass_recorder() original_tz = dt_util.DEFAULT_TIME_ZONE tz = dt_util.get_time_zone("Europe/Copenhagen") dt_util.set_default_time_zone(tz) now = dt_util.utcnow() test_time = tz.localize(datetime(now.year + 1, 1, 1, 4, 12, 0)) async_fire_time_changed(hass, test_time) with patch("homeassistant.components.recorder.purge.purge_old_data", return_value=True) as purge_old_data: for delta in (-1, 0, 1): async_fire_time_changed(hass, test_time + timedelta(seconds=delta)) hass.block_till_done() hass.data[DATA_INSTANCE].block_till_done() assert len(purge_old_data.mock_calls) == 1 dt_util.set_default_time_zone(original_tz)
async def test_dst(hass, freezer, hass_tz_info): """Test sun event with offset.""" hass.config.time_zone = "CET" dt_util.set_default_time_zone(dt_util.get_time_zone("CET")) test_time = datetime(2019, 3, 30, 3, 0, 0, tzinfo=hass_tz_info) config = { "binary_sensor": [ {"platform": "tod", "name": "Day", "after": "2:30", "before": "2:40"} ] } # Test DST: # after 2019-03-30 03:00 CET the next update should ge scheduled # at 3:30 not 2:30 local time entity_id = "binary_sensor.day" freezer.move_to(test_time) await async_setup_component(hass, "binary_sensor", config) await hass.async_block_till_done() await hass.async_block_till_done() state = hass.states.get(entity_id) assert state.attributes["after"] == "2019-03-31T03:30:00+02:00" assert state.attributes["before"] == "2019-03-31T03:40:00+02:00" assert state.attributes["next_update"] == "2019-03-31T03:30:00+02:00" assert state.state == STATE_OFF
def test_find_next_time_expression_time_leave_dst_chicago_past_the_fold_ahead_2_hour_10_min(): """Test leaving daylight saving time for find_next_time_expression_time.""" tz = dt_util.get_time_zone("America/Chicago") dt_util.set_default_time_zone(tz) # Leaving DST, clocks are rolled back # Find 1h 10m after into the fold # Start at 01:30:01 fold=0 # Reach to 02:20:01 past the fold hour_minute_second = (2, 20, 1) test_time = datetime(2021, 11, 7, 1, 30, 1, tzinfo=tz, fold=0) matching_hours, matching_minutes, matching_seconds = _get_matches( *hour_minute_second ) next_time = dt_util.find_next_time_expression_time( test_time, matching_seconds, matching_minutes, matching_hours ) assert next_time == datetime(2021, 11, 7, *hour_minute_second, tzinfo=tz, fold=1) assert next_time.fold == 0 # Time is no longer ambiguous assert dt_util.as_utc(next_time) == datetime( 2021, 11, 7, 8, 20, 1, tzinfo=dt_util.UTC )
def test_find_next_time_expression_time_leave_dst_chicago_inside_the_fold_ahead_10_min(): """Test leaving daylight saving time for find_next_time_expression_time.""" tz = dt_util.get_time_zone("America/Chicago") dt_util.set_default_time_zone(tz) # Leaving DST, clocks are rolled back # Find 10m later while we are in the fold # Start at 01:30:01 fold=0 # Reach to 01:40:01 fold=1 hour_minute_second = (1, 40, 1) test_time = datetime(2021, 11, 7, 1, 30, 1, tzinfo=tz, fold=1) matching_hours, matching_minutes, matching_seconds = _get_matches( *hour_minute_second ) next_time = dt_util.find_next_time_expression_time( test_time, matching_seconds, matching_minutes, matching_hours ) assert next_time == datetime(2021, 11, 7, *hour_minute_second, tzinfo=tz, fold=1) assert next_time.fold == 1 # time is ambiguous assert dt_util.as_utc(next_time) == datetime( 2021, 11, 7, 7, 40, 1, tzinfo=dt_util.UTC )
def forecast(self, src=None): """Return the forecast array.""" src = src or self._forecast forecast = [] now = int(time.time()) dt_util.set_default_time_zone(self._timezone) for i in src: fc_time = i.get(ATTR_FORECAST_TIME) if fc_time is None: continue data = { ATTR_FORECAST_TIME: dt_util.as_local( datetime.utcfromtimestamp(fc_time) ).isoformat(), ATTR_FORECAST_CONDITION: self.condition(i), ATTR_FORECAST_TEMP: self.temperature(i), ATTR_FORECAST_PRESSURE: self.pressure_hpa(i), ATTR_FORECAST_HUMIDITY: self.humidity(i), ATTR_FORECAST_WIND_SPEED: self.wind_speed_kmh(i), ATTR_FORECAST_WIND_BEARING: self.wind_bearing(i), ATTR_FORECAST_PRECIPITATION: self.precipitation_amount(i), } if ( self._mode == FORECAST_MODE_DAILY and i.get(ATTR_FORECAST_TEMP_LOW) is not None ): data[ATTR_FORECAST_TEMP_LOW] = i.get(ATTR_FORECAST_TEMP_LOW) if fc_time < now: forecast = [data] else: forecast.append(data) return forecast
async def test_timezone_intervals(hass): """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(hass, "date") now = dt_util.utc_from_timestamp(50000) with patch("homeassistant.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(hass, "date") with patch("homeassistant.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("homeassistant.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("homeassistant.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("homeassistant.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("homeassistant.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 baghdad(): """Set the default TZ to Asia/Baghdad.""" dt.set_default_time_zone(dt.get_time_zone("Asia/Baghdad"))
def tearDown(self): """Stop everything that was started.""" dt_util.set_default_time_zone(self.orig_default_time_zone)
def teardown(): """Restore.""" yield dt_util.set_default_time_zone(ORIG_TIME_ZONE)
def teardown(): """Stop everything that was started.""" dt_util.set_default_time_zone(DEFAULT_TIME_ZONE)
def restore_timezone(hass): """Make sure we change timezone.""" yield dt_util.set_default_time_zone(ORIG_TIMEZONE)
def teardown_method(self, method): """Stop everything that was started.""" self.hass.stop() # Reset the default timezone, so we don't affect other tests set_default_time_zone(get_time_zone('UTC'))
async def test_periodic_task_leaving_dst(hass): """Test periodic task behavior when leaving dst.""" timezone = dt_util.get_time_zone("Europe/Vienna") dt_util.set_default_time_zone(timezone) specific_runs = [] now = dt_util.utcnow() time_that_will_not_match_right_away = timezone.localize(datetime( now.year + 1, 10, 28, 2, 28, 0), is_dst=True) with patch("homeassistant.util.dt.utcnow", return_value=time_that_will_not_match_right_away): unsub = async_track_time_change( hass, callback(lambda x: specific_runs.append(x)), hour=2, minute=30, second=0, ) async_fire_time_changed( hass, timezone.localize(datetime(now.year + 1, 10, 28, 2, 5, 0, 999999), is_dst=False), ) await hass.async_block_till_done() assert len(specific_runs) == 0 async_fire_time_changed( hass, timezone.localize(datetime(now.year + 1, 10, 28, 2, 55, 0, 999999), is_dst=False), ) await hass.async_block_till_done() assert len(specific_runs) == 1 async_fire_time_changed( hass, timezone.localize(datetime(now.year + 2, 10, 28, 2, 45, 0, 999999), is_dst=True), ) await hass.async_block_till_done() assert len(specific_runs) == 2 async_fire_time_changed( hass, timezone.localize(datetime(now.year + 2, 10, 28, 2, 55, 0, 999999), is_dst=True), ) await hass.async_block_till_done() assert len(specific_runs) == 2 async_fire_time_changed( hass, timezone.localize(datetime(now.year + 2, 10, 28, 2, 55, 0, 999999), is_dst=True), ) await hass.async_block_till_done() assert len(specific_runs) == 2 unsub()
def tearDown(self): """Stop everything that was started.""" dt_util.set_default_time_zone(dt_util.get_time_zone('UTC')) self.hass.stop()
async def test_timestamp(hass): """Test timestamp.""" try: dt_util.set_default_time_zone( dt_util.get_time_zone("America/Los_Angeles")) assert await async_setup_component( hass, 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 = hass.states.get( "input_datetime.test_datetime_initial_with_tz") assert state_with_tz is not None 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 = hass.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" 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])).strftime( FMT_DATETIME) == "2020-12-13 10:00:00") # Test initial time sets timestamp correctly. state_time = hass.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 hass.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 = hass.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)
def test_monthly_statistics(hass_recorder, caplog, timezone): """Test inserting external statistics.""" dt_util.set_default_time_zone(dt_util.get_time_zone(timezone)) hass = hass_recorder() wait_recording_done(hass) assert "Compiling statistics for" not in caplog.text assert "Statistics already compiled" not in caplog.text zero = dt_util.utcnow() period1 = dt_util.as_utc(dt_util.parse_datetime("2021-09-01 00:00:00")) period2 = dt_util.as_utc(dt_util.parse_datetime("2021-09-30 23:00:00")) period3 = dt_util.as_utc(dt_util.parse_datetime("2021-10-01 00:00:00")) period4 = dt_util.as_utc(dt_util.parse_datetime("2021-10-31 23:00:00")) external_statistics = ( { "start": period1, "last_reset": None, "state": 0, "sum": 2, }, { "start": period2, "last_reset": None, "state": 1, "sum": 3, }, { "start": period3, "last_reset": None, "state": 2, "sum": 4, }, { "start": period4, "last_reset": None, "state": 3, "sum": 5, }, ) external_metadata = { "has_mean": False, "has_sum": True, "name": "Total imported energy", "source": "test", "statistic_id": "test:total_energy_import", "unit_of_measurement": "kWh", } async_add_external_statistics(hass, external_metadata, external_statistics) wait_recording_done(hass) stats = statistics_during_period(hass, zero, period="month") sep_start = dt_util.as_utc(dt_util.parse_datetime("2021-09-01 00:00:00")) sep_end = dt_util.as_utc(dt_util.parse_datetime("2021-10-01 00:00:00")) oct_start = dt_util.as_utc(dt_util.parse_datetime("2021-10-01 00:00:00")) oct_end = dt_util.as_utc(dt_util.parse_datetime("2021-11-01 00:00:00")) assert stats == { "test:total_energy_import": [ { "statistic_id": "test:total_energy_import", "start": sep_start.isoformat(), "end": sep_end.isoformat(), "max": None, "mean": None, "min": None, "last_reset": None, "state": approx(1.0), "sum": approx(3.0), }, { "statistic_id": "test:total_energy_import", "start": oct_start.isoformat(), "end": oct_end.isoformat(), "max": None, "mean": None, "min": None, "last_reset": None, "state": approx(3.0), "sum": approx(5.0), }, ] } dt_util.set_default_time_zone(dt_util.get_time_zone("UTC"))
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) -> datetime: """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) local = dt_util.find_next_time_expression_time(dt, seconds, minutes, hours) return dt_util.as_utc(local) # Entering DST, clocks are rolled forward assert dt_util.as_utc(datetime(2021, 3, 15, 2, 30, 0, tzinfo=tz)) == find( datetime(2021, 3, 14, 1, 50, 0, tzinfo=tz), 2, 30, 0) assert dt_util.as_utc(datetime(2021, 3, 15, 2, 30, 0, tzinfo=tz)) == find( datetime(2021, 3, 14, 3, 50, 0, tzinfo=tz), 2, 30, 0) assert dt_util.as_utc(datetime(2021, 3, 15, 2, 30, 0, tzinfo=tz)) == find( datetime(2021, 3, 14, 1, 50, 0, tzinfo=tz), 2, 30, 0) assert dt_util.as_utc(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 dt_util.as_utc(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 dt_util.as_utc(datetime(2021, 11, 7, 2, 30, 0, tzinfo=tz)) == find( datetime(2021, 11, 7, 2, 5, 0, tzinfo=tz), 2, 30, 0) assert dt_util.as_utc(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 dt_util.as_utc(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 dt_util.as_utc(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 dt_util.as_utc(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 dt_util.as_utc(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 dt_util.as_utc(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 dt_util.as_utc(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 new_york(): """Set the default TZ to America/New_York.""" dt.set_default_time_zone(dt.get_time_zone("America/New_York"))
async def test_if_action_after_sunset_no_offset_kotzebue(hass, 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) hass.config.latitude = 66.5 hass.config.longitude = 162.4 await async_setup_component( hass, 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("homeassistant.util.dt.utcnow", return_value=now): hass.bus.async_fire("test_event") await hass.async_block_till_done() assert len(calls) == 1 # now = sunset - 1s -> 'after sunset' not true now = datetime(2015, 7, 25, 11, 16, 26, tzinfo=dt_util.UTC) with patch("homeassistant.util.dt.utcnow", return_value=now): hass.bus.async_fire("test_event") await hass.async_block_till_done() assert len(calls) == 1 # now = local midnight -> 'after sunset' not true now = datetime(2015, 7, 24, 8, 0, 1, tzinfo=dt_util.UTC) with patch("homeassistant.util.dt.utcnow", return_value=now): hass.bus.async_fire("test_event") await hass.async_block_till_done() assert len(calls) == 1 # now = local midnight - 1s -> 'after sunset' true now = datetime(2015, 7, 24, 7, 59, 59, tzinfo=dt_util.UTC) with patch("homeassistant.util.dt.utcnow", return_value=now): hass.bus.async_fire("test_event") await hass.async_block_till_done() assert len(calls) == 2
def utc(): """Set the default TZ to UTC.""" dt.set_default_time_zone(dt.get_time_zone("UTC"))
import logging from homeassistant.util import dt as dt_util from datetime import timedelta from csv import writer import matplotlib.pyplot as plt _LOGGER = logging.getLogger(__name__) if __name__ == '__main__': from custom_components.circadian_white.sensor import CircadianWhiteSensor # When to simulate dt_util.set_default_time_zone(dt_util.get_time_zone('Australia/Melbourne')) now = dt_util.now() day_start = now.replace(hour=7, minute=1, second=42) day_middle = now.replace(hour=12, minute=19, second=32) day_end = now.replace(hour=17, minute=37, second=26) circ = CircadianWhiteSensor('test_math', 2500, 4500, 6500, 2, 3) for offset in range(24): print("Offset {}".format(offset)) test_now = now.replace(hour=offset, minute=0, second=0) circ._calculate_day_events(test_now, day_start, day_middle, day_end) print(circ._day_start) print(day_start) print(circ._day_middle) print(day_middle) print(circ._day_end) print(day_end)
def async_test_home_assistant(loop): """Return a Home Assistant object pointing at test config dir.""" hass = ha.HomeAssistant(loop) hass.config.async_load = Mock() store = auth_store.AuthStore(hass) hass.auth = auth.AuthManager(hass, store, {}, {}) ensure_auth_manager_loaded(hass.auth) INSTANCES.append(hass) orig_async_add_job = hass.async_add_job orig_async_add_executor_job = hass.async_add_executor_job orig_async_create_task = hass.async_create_task def async_add_job(target, *args): """Add job.""" if isinstance(target, Mock): return mock_coro(target(*args)) return orig_async_add_job(target, *args) def async_add_executor_job(target, *args): """Add executor job.""" if isinstance(target, Mock): return mock_coro(target(*args)) return orig_async_add_executor_job(target, *args) def async_create_task(coroutine): """Create task.""" if isinstance(coroutine, Mock): return mock_coro() return orig_async_create_task(coroutine) hass.async_add_job = async_add_job hass.async_add_executor_job = async_add_executor_job hass.async_create_task = async_create_task hass.config.location_name = "test home" hass.config.latitude = 51.8391 hass.config.longitude = 5.8739 hass.config.elevation = 0 hass.config.time_zone = date_util.get_time_zone("Europe/Amsterdam") hass.config.units = METRIC_SYSTEM hass.config.skip_pip = True date_util.set_default_time_zone(hass.config.time_zone) hass.config_entries = config_entries.ConfigEntries(hass, {}) hass.config_entries._entries = [] hass.config_entries._store._async_ensure_stop_listener = lambda: None hass.state = ha.CoreState.running # Mock async_start orig_start = hass.async_start @asyncio.coroutine def mock_async_start(): """Start the mocking.""" # We only mock time during tests and we want to track tasks with patch("homeassistant.core._async_create_timer"), patch.object( hass, "async_stop_track_tasks"): yield from orig_start() hass.async_start = mock_async_start @ha.callback def clear_instance(event): """Clear global instance.""" INSTANCES.remove(hass) hass.bus.async_listen_once(EVENT_HOMEASSISTANT_CLOSE, clear_instance) return hass
def tearDown(self): """Stop everything that was started.""" dt_util.set_default_time_zone(self.DEFAULT_TIME_ZONE) self.hass.stop()
def tearDown(self): dt_util.set_default_time_zone(self.orig_default_time_zone)
def teardown_module(): """Reset time zone.""" dt_util.set_default_time_zone(ORIG_TIME_ZONE)