desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Test the icon.'
| def test_icon(self):
| for name in self.sensor_dict:
sensor = self.sensor_dict[name]['sensor']
self.assertEqual(self.sensor_dict[name]['icon'], sensor.icon)
|
'Test the initial state.'
| @requests_mock.Mocker()
def test_state(self, mock_req):
| self.setup_api(MOCK_DATA, mock_req)
now = datetime(1970, month=1, day=1)
with patch('homeassistant.util.dt.now', return_value=now):
for name in self.sensor_dict:
sensor = self.sensor_dict[name]['sensor']
self.fake_delay(2)
sensor.update()
if (name == google_wifi.ATTR_LAST_RESTART):
self.assertEqual('1969-12-31 00:00:00', sensor.state)
elif (name == google_wifi.ATTR_UPTIME):
self.assertEqual(1, sensor.state)
elif (name == google_wifi.ATTR_STATUS):
self.assertEqual('Online', sensor.state)
else:
self.assertEqual('initial', sensor.state)
|
'Test state gets updated to unknown when sensor returns no data.'
| @requests_mock.Mocker()
def test_update_when_value_is_none(self, mock_req):
| self.setup_api(None, mock_req)
for name in self.sensor_dict:
sensor = self.sensor_dict[name]['sensor']
self.fake_delay(2)
sensor.update()
self.assertEqual(STATE_UNKNOWN, sensor.state)
|
'Test state gets updated when sensor returns a new status.'
| @requests_mock.Mocker()
def test_update_when_value_changed(self, mock_req):
| self.setup_api(MOCK_DATA_NEXT, mock_req)
now = datetime(1970, month=1, day=1)
with patch('homeassistant.util.dt.now', return_value=now):
for name in self.sensor_dict:
sensor = self.sensor_dict[name]['sensor']
self.fake_delay(2)
sensor.update()
if (name == google_wifi.ATTR_LAST_RESTART):
self.assertEqual('1969-12-30 00:00:00', sensor.state)
elif (name == google_wifi.ATTR_UPTIME):
self.assertEqual(2, sensor.state)
elif (name == google_wifi.ATTR_STATUS):
self.assertEqual('Offline', sensor.state)
elif (name == google_wifi.ATTR_NEW_VERSION):
self.assertEqual('Latest', sensor.state)
elif (name == google_wifi.ATTR_LOCAL_IP):
self.assertEqual(STATE_UNKNOWN, sensor.state)
else:
self.assertEqual('next', sensor.state)
|
'Test state logs an error when data is missing.'
| @requests_mock.Mocker()
def test_when_api_data_missing(self, mock_req):
| self.setup_api(MOCK_DATA_MISSING, mock_req)
now = datetime(1970, month=1, day=1)
with patch('homeassistant.util.dt.now', return_value=now):
for name in self.sensor_dict:
sensor = self.sensor_dict[name]['sensor']
self.fake_delay(2)
sensor.update()
self.assertEqual(STATE_UNKNOWN, sensor.state)
|
'Test state updates when Google Wifi unavailable.'
| def test_update_when_unavailable(self):
| self.api.update = Mock('google_wifi.GoogleWifiAPI.update', side_effect=self.update_side_effect())
for name in self.sensor_dict:
sensor = self.sensor_dict[name]['sensor']
sensor.update()
self.assertEqual(STATE_UNKNOWN, sensor.state)
|
'Mock representation of update function.'
| def update_side_effect(self):
| self.api.data = None
self.api.available = False
|
'Setup things to be run when tests are started.'
| def setUp(self):
| self.hass = get_test_home_assistant()
mock_mqtt_component(self.hass)
|
'Stop down everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Test the setting of the value via MQTT.'
| def test_setting_sensor_value_via_mqtt_message(self):
| mock_component(self.hass, 'mqtt')
assert setup_component(self.hass, sensor.DOMAIN, {sensor.DOMAIN: {'platform': 'mqtt', 'name': 'test', 'state_topic': 'test-topic', 'unit_of_measurement': 'fav unit'}})
fire_mqtt_message(self.hass, 'test-topic', '100')
self.hass.block_till_done()
state = self.hass.states.get('sensor.test')
self.assertEqual('100', state.state)
self.assertEqual('fav unit', state.attributes.get('unit_of_measurement'))
|
'Test the expiration of the value.'
| @patch('homeassistant.core.dt_util.utcnow')
def test_setting_sensor_value_expires(self, mock_utcnow):
| mock_component(self.hass, 'mqtt')
assert setup_component(self.hass, sensor.DOMAIN, {sensor.DOMAIN: {'platform': 'mqtt', 'name': 'test', 'state_topic': 'test-topic', 'unit_of_measurement': 'fav unit', 'expire_after': '4', 'force_update': True}})
state = self.hass.states.get('sensor.test')
self.assertEqual('unknown', state.state)
now = datetime(2017, 1, 1, 1, tzinfo=dt_util.UTC)
mock_utcnow.return_value = now
fire_mqtt_message(self.hass, 'test-topic', '100')
self.hass.block_till_done()
state = self.hass.states.get('sensor.test')
self.assertEqual('100', state.state)
now = (now + timedelta(seconds=3))
self._send_time_changed(now)
self.hass.block_till_done()
state = self.hass.states.get('sensor.test')
self.assertEqual('100', state.state)
mock_utcnow.return_value = now
fire_mqtt_message(self.hass, 'test-topic', '101')
self.hass.block_till_done()
state = self.hass.states.get('sensor.test')
self.assertEqual('101', state.state)
now = (now + timedelta(seconds=3))
self._send_time_changed(now)
self.hass.block_till_done()
state = self.hass.states.get('sensor.test')
self.assertEqual('101', state.state)
now = (now + timedelta(seconds=2))
self._send_time_changed(now)
self.hass.block_till_done()
state = self.hass.states.get('sensor.test')
self.assertEqual('unknown', state.state)
|
'Test the setting of the value via MQTT with JSON playload.'
| def test_setting_sensor_value_via_mqtt_json_message(self):
| mock_component(self.hass, 'mqtt')
assert setup_component(self.hass, sensor.DOMAIN, {sensor.DOMAIN: {'platform': 'mqtt', 'name': 'test', 'state_topic': 'test-topic', 'unit_of_measurement': 'fav unit', 'value_template': '{{ value_json.val }}'}})
fire_mqtt_message(self.hass, 'test-topic', '{ "val": "100" }')
self.hass.block_till_done()
state = self.hass.states.get('sensor.test')
self.assertEqual('100', state.state)
|
'Test force update option.'
| def test_force_update_disabled(self):
| mock_component(self.hass, 'mqtt')
assert setup_component(self.hass, sensor.DOMAIN, {sensor.DOMAIN: {'platform': 'mqtt', 'name': 'test', 'state_topic': 'test-topic', 'unit_of_measurement': 'fav unit'}})
events = []
@ha.callback
def callback(event):
events.append(event)
self.hass.bus.listen(EVENT_STATE_CHANGED, callback)
fire_mqtt_message(self.hass, 'test-topic', '100')
self.hass.block_till_done()
self.assertEqual(1, len(events))
fire_mqtt_message(self.hass, 'test-topic', '100')
self.hass.block_till_done()
self.assertEqual(1, len(events))
|
'Test force update option.'
| def test_force_update_enabled(self):
| mock_component(self.hass, 'mqtt')
assert setup_component(self.hass, sensor.DOMAIN, {sensor.DOMAIN: {'platform': 'mqtt', 'name': 'test', 'state_topic': 'test-topic', 'unit_of_measurement': 'fav unit', 'force_update': True}})
events = []
@ha.callback
def callback(event):
events.append(event)
self.hass.bus.listen(EVENT_STATE_CHANGED, callback)
fire_mqtt_message(self.hass, 'test-topic', '100')
self.hass.block_till_done()
self.assertEqual(1, len(events))
fire_mqtt_message(self.hass, 'test-topic', '100')
self.hass.block_till_done()
self.assertEqual(2, len(events))
|
'Send a time changed event.'
| def _send_time_changed(self, now):
| self.hass.bus.fire(ha.EVENT_TIME_CHANGED, {ha.ATTR_NOW: now})
|
'Mock add devices.'
| def add_devices(self, devices):
| for device in devices:
self.DEVICES.append(device)
|
'Initialize values for this testcase class.'
| def setUp(self):
| self.hass = get_test_home_assistant()
self.username = 'foo'
self.password = 'bar'
self.config = {'username': self.username, 'password': self.password}
|
'Stop everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Test for successfully setting up the SleepIQ platform.'
| @requests_mock.Mocker()
def test_setup(self, mock):
| mock_responses(mock)
assert setup_component(self.hass, 'sleepiq', {'sleepiq': {'username': '', 'password': ''}})
sleepiq.setup_platform(self.hass, self.config, self.add_devices, MagicMock())
self.assertEqual(2, len(self.DEVICES))
left_side = self.DEVICES[1]
self.assertEqual('SleepNumber ILE Test1 SleepNumber', left_side.name)
self.assertEqual(40, left_side.state)
right_side = self.DEVICES[0]
self.assertEqual('SleepNumber ILE Test2 SleepNumber', right_side.name)
self.assertEqual(80, right_side.state)
|
'Initialize values for this testcase class.'
| def setUp(self):
| self.hass = get_test_home_assistant()
self.config = VALID_CONFIG
|
'Stop everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Test for operational tube_state sensor with proper attributes.'
| @requests_mock.Mocker()
def test_setup(self, mock_req):
| mock_req.get(URL, text=load_fixture('london_underground.json'))
self.assertTrue(setup_component(self.hass, 'sensor', {'sensor': self.config}))
state = self.hass.states.get('sensor.london_overground')
assert (state.state == 'Minor Delays')
assert (state.attributes.get('Description') == 'something')
|
'Mock add devices.'
| def add_devices(self, devices, update):
| for device in devices:
self.DEVICES.append(device)
|
'Initialize values for this testcase class.'
| def setUp(self):
| self.DEVICES = []
self.hass = get_test_home_assistant()
self.hass.config.time_zone = 'America/Los_Angeles'
|
'Stop everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Test getting all disk space.'
| @unittest.mock.patch('requests.get', side_effect=mocked_requests_get)
def test_diskspace_no_paths(self, req_mock):
| config = {'platform': 'sonarr', 'api_key': 'foo', 'days': '2', 'unit': 'GB', 'include_paths': [], 'monitored_conditions': ['diskspace']}
sonarr.setup_platform(self.hass, config, self.add_devices, None)
for device in self.DEVICES:
device.update()
self.assertEqual('263.10', device.state)
self.assertEqual('mdi:harddisk', device.icon)
self.assertEqual('GB', device.unit_of_measurement)
self.assertEqual('Sonarr Disk Space', device.name)
self.assertEqual('263.10/465.42GB (56.53%)', device.device_state_attributes['/data'])
|
'Test getting diskspace for included paths.'
| @unittest.mock.patch('requests.get', side_effect=mocked_requests_get)
def test_diskspace_paths(self, req_mock):
| config = {'platform': 'sonarr', 'api_key': 'foo', 'days': '2', 'unit': 'GB', 'include_paths': ['/data'], 'monitored_conditions': ['diskspace']}
sonarr.setup_platform(self.hass, config, self.add_devices, None)
for device in self.DEVICES:
device.update()
self.assertEqual('263.10', device.state)
self.assertEqual('mdi:harddisk', device.icon)
self.assertEqual('GB', device.unit_of_measurement)
self.assertEqual('Sonarr Disk Space', device.name)
self.assertEqual('263.10/465.42GB (56.53%)', device.device_state_attributes['/data'])
|
'Test getting running commands.'
| @unittest.mock.patch('requests.get', side_effect=mocked_requests_get)
def test_commands(self, req_mock):
| config = {'platform': 'sonarr', 'api_key': 'foo', 'days': '2', 'unit': 'GB', 'include_paths': ['/data'], 'monitored_conditions': ['commands']}
sonarr.setup_platform(self.hass, config, self.add_devices, None)
for device in self.DEVICES:
device.update()
self.assertEqual(1, device.state)
self.assertEqual('mdi:code-braces', device.icon)
self.assertEqual('Commands', device.unit_of_measurement)
self.assertEqual('Sonarr Commands', device.name)
self.assertEqual('pending', device.device_state_attributes['RescanSeries'])
|
'Test getting downloads in the queue.'
| @unittest.mock.patch('requests.get', side_effect=mocked_requests_get)
def test_queue(self, req_mock):
| config = {'platform': 'sonarr', 'api_key': 'foo', 'days': '2', 'unit': 'GB', 'include_paths': ['/data'], 'monitored_conditions': ['queue']}
sonarr.setup_platform(self.hass, config, self.add_devices, None)
for device in self.DEVICES:
device.update()
self.assertEqual(1, device.state)
self.assertEqual('mdi:download', device.icon)
self.assertEqual('Episodes', device.unit_of_measurement)
self.assertEqual('Sonarr Queue', device.name)
self.assertEqual('100.00%', device.device_state_attributes['Game of Thrones S03E08'])
|
'Test getting the number of series.'
| @unittest.mock.patch('requests.get', side_effect=mocked_requests_get)
def test_series(self, req_mock):
| config = {'platform': 'sonarr', 'api_key': 'foo', 'days': '2', 'unit': 'GB', 'include_paths': ['/data'], 'monitored_conditions': ['series']}
sonarr.setup_platform(self.hass, config, self.add_devices, None)
for device in self.DEVICES:
device.update()
self.assertEqual(1, device.state)
self.assertEqual('mdi:television', device.icon)
self.assertEqual('Shows', device.unit_of_measurement)
self.assertEqual('Sonarr Series', device.name)
self.assertEqual('26/26 Episodes', device.device_state_attributes["Marvel's Daredevil"])
|
'Test getting wanted episodes.'
| @unittest.mock.patch('requests.get', side_effect=mocked_requests_get)
def test_wanted(self, req_mock):
| config = {'platform': 'sonarr', 'api_key': 'foo', 'days': '2', 'unit': 'GB', 'include_paths': ['/data'], 'monitored_conditions': ['wanted']}
sonarr.setup_platform(self.hass, config, self.add_devices, None)
for device in self.DEVICES:
device.update()
self.assertEqual(1, device.state)
self.assertEqual('mdi:television', device.icon)
self.assertEqual('Episodes', device.unit_of_measurement)
self.assertEqual('Sonarr Wanted', device.name)
self.assertEqual('2014-02-03', device.device_state_attributes['Archer (2009) S05E04'])
|
'Test the upcoming episodes for multiple days.'
| @unittest.mock.patch('requests.get', side_effect=mocked_requests_get)
def test_upcoming_multiple_days(self, req_mock):
| config = {'platform': 'sonarr', 'api_key': 'foo', 'days': '2', 'unit': 'GB', 'include_paths': ['/data'], 'monitored_conditions': ['upcoming']}
sonarr.setup_platform(self.hass, config, self.add_devices, None)
for device in self.DEVICES:
device.update()
self.assertEqual(1, device.state)
self.assertEqual('mdi:television', device.icon)
self.assertEqual('Episodes', device.unit_of_measurement)
self.assertEqual('Sonarr Upcoming', device.name)
self.assertEqual('S04E11', device.device_state_attributes["Bob's Burgers"])
|
'Test filtering for a single day.
Sonarr needs to respond with at least 2 days'
| @pytest.mark.skip
@unittest.mock.patch('requests.get', side_effect=mocked_requests_get)
def test_upcoming_today(self, req_mock):
| config = {'platform': 'sonarr', 'api_key': 'foo', 'days': '1', 'unit': 'GB', 'include_paths': ['/data'], 'monitored_conditions': ['upcoming']}
sonarr.setup_platform(self.hass, config, self.add_devices, None)
for device in self.DEVICES:
device.update()
self.assertEqual(1, device.state)
self.assertEqual('mdi:television', device.icon)
self.assertEqual('Episodes', device.unit_of_measurement)
self.assertEqual('Sonarr Upcoming', device.name)
self.assertEqual('S04E11', device.device_state_attributes["Bob's Burgers"])
|
'Test SSL being enabled.'
| @pytest.mark.skip
@unittest.mock.patch('requests.get', side_effect=mocked_requests_get)
def test_ssl(self, req_mock):
| config = {'platform': 'sonarr', 'api_key': 'foo', 'days': '1', 'unit': 'GB', 'include_paths': ['/data'], 'monitored_conditions': ['upcoming'], 'ssl': 'true'}
sonarr.setup_platform(self.hass, config, self.add_devices, None)
for device in self.DEVICES:
device.update()
self.assertEqual(1, device.state)
self.assertEqual('s', device.ssl)
self.assertEqual('mdi:television', device.icon)
self.assertEqual('Episodes', device.unit_of_measurement)
self.assertEqual('Sonarr Upcoming', device.name)
self.assertEqual('S04E11', device.device_state_attributes["Bob's Burgers"])
|
'Test exception being handled.'
| @unittest.mock.patch('requests.get', side_effect=mocked_exception)
def test_exception_handling(self, req_mock):
| config = {'platform': 'sonarr', 'api_key': 'foo', 'days': '1', 'unit': 'GB', 'include_paths': ['/data'], 'monitored_conditions': ['upcoming']}
sonarr.setup_platform(self.hass, config, self.add_devices, None)
for device in self.DEVICES:
device.update()
self.assertEqual(None, device.state)
|
'Mock add entities.'
| def add_entities(self, new_entities, update_before_add=False):
| if update_before_add:
for entity in new_entities:
entity.update()
for entity in new_entities:
self.entities.append(entity)
|
'Initialize values for this testcase class.'
| def setUp(self):
| self.hass = get_test_home_assistant()
self.key = 'foo'
self.config = {'api_key': 'foo', 'forecast': [1, 2], 'monitored_conditions': ['summary', 'icon', 'temperature_max'], 'update_interval': timedelta(seconds=120)}
self.lat = self.hass.config.latitude = 37.8267
self.lon = self.hass.config.longitude = (-122.423)
self.entities = []
|
'Stop everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Test the platform setup with configuration.'
| def test_setup_with_config(self):
| self.assertTrue(setup_component(self.hass, 'sensor', {'darksky': self.config}))
|
'Test for handling a bad API key.'
| @patch('forecastio.api.get_forecast')
def test_setup_bad_api_key(self, mock_get_forecast):
| url = 'https://api.darksky.net/forecast/{}/{},{}?units=auto'.format(self.key, str(self.lat), str(self.lon))
msg = '400 Client Error: Bad Request for url: {}'.format(url)
mock_get_forecast.side_effect = HTTPError(msg)
response = darksky.setup_platform(self.hass, self.config, MagicMock())
self.assertFalse(response)
|
'Test for successfully setting up the forecast.io platform.'
| @requests_mock.Mocker()
@patch('forecastio.api.get_forecast', wraps=forecastio.api.get_forecast)
def test_setup(self, mock_req, mock_get_forecast):
| uri = 'https://api.(darksky.net|forecast.io)\\/forecast\\/(\\w+)\\/(-?\\d+\\.?\\d*),(-?\\d+\\.?\\d*)'
mock_req.get(re.compile(uri), text=load_fixture('darksky.json'))
darksky.setup_platform(self.hass, self.config, self.add_entities)
self.assertTrue(mock_get_forecast.called)
self.assertEqual(mock_get_forecast.call_count, 1)
self.assertEqual(len(self.entities), 7)
|
'Initialize values for this testcase class.'
| def setUp(self):
| self.hass = get_test_home_assistant()
self.config = VALID_CONFIG
|
'Stop everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Test for operational uk_transport sensor with proper attributes.'
| @requests_mock.Mocker()
def test_bus(self, mock_req):
| with requests_mock.Mocker() as mock_req:
uri = re.compile((UkTransportSensor.TRANSPORT_API_URL_BASE + '*'))
mock_req.get(uri, text=load_fixture('uk_transport_bus.json'))
self.assertTrue(setup_component(self.hass, 'sensor', {'sensor': self.config}))
bus_state = self.hass.states.get('sensor.next_bus_to_wantage')
assert (type(bus_state.state) == str)
assert (bus_state.name == 'Next bus to {}'.format(BUS_DIRECTION))
assert (bus_state.attributes.get(ATTR_ATCOCODE) == BUS_ATCOCODE)
assert (bus_state.attributes.get(ATTR_LOCALITY) == 'Harwell Campus')
assert (bus_state.attributes.get(ATTR_STOP_NAME) == 'Bus Station')
assert (len(bus_state.attributes.get(ATTR_NEXT_BUSES)) == 2)
direction_re = re.compile(BUS_DIRECTION)
for bus in bus_state.attributes.get(ATTR_NEXT_BUSES):
print (bus['direction'], direction_re.match(bus['direction']))
assert (direction_re.search(bus['direction']) is not None)
|
'Test for operational uk_transport sensor with proper attributes.'
| @requests_mock.Mocker()
def test_train(self, mock_req):
| with requests_mock.Mocker() as mock_req:
uri = re.compile((UkTransportSensor.TRANSPORT_API_URL_BASE + '*'))
mock_req.get(uri, text=load_fixture('uk_transport_train.json'))
self.assertTrue(setup_component(self.hass, 'sensor', {'sensor': self.config}))
train_state = self.hass.states.get('sensor.next_train_to_WAT')
assert (type(train_state.state) == str)
assert (train_state.name == 'Next train to {}'.format(TRAIN_DESTINATION_NAME))
assert (train_state.attributes.get(ATTR_STATION_CODE) == TRAIN_STATION_CODE)
assert (train_state.attributes.get(ATTR_CALLING_AT) == TRAIN_DESTINATION_NAME)
assert (len(train_state.attributes.get(ATTR_NEXT_TRAINS)) == 25)
assert (train_state.attributes.get(ATTR_NEXT_TRAINS)[0]['destination_name'] == 'London Waterloo')
assert (train_state.attributes.get(ATTR_NEXT_TRAINS)[0]['estimated'] == '06:13')
|
'Mock add devices.'
| @requests_mock.Mocker()
def add_devices(self, devices, mock):
| mock_responses(mock)
for device in devices:
device.update()
self.DEVICES.append(device)
|
'Initialize values for this testcase class.'
| def setUp(self):
| self.hass = get_test_home_assistant()
self.config = ONE_SENSOR_CONFIG
|
'Stop everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Test for successfully setting up the Efergy platform.'
| @requests_mock.Mocker()
def test_single_sensor_readings(self, mock):
| mock_responses(mock)
assert setup_component(self.hass, 'sensor', {'sensor': ONE_SENSOR_CONFIG})
self.assertEqual('38.21', self.hass.states.get('sensor.energy_consumed').state)
self.assertEqual('1580', self.hass.states.get('sensor.energy_usage').state)
self.assertEqual('ok', self.hass.states.get('sensor.energy_budget').state)
self.assertEqual('5.27', self.hass.states.get('sensor.energy_cost').state)
self.assertEqual('1628', self.hass.states.get('sensor.efergy_728386').state)
|
'Test for multiple sensors in one household.'
| @requests_mock.Mocker()
def test_multi_sensor_readings(self, mock):
| mock_responses(mock)
assert setup_component(self.hass, 'sensor', {'sensor': MULTI_SENSOR_CONFIG})
self.assertEqual('218', self.hass.states.get('sensor.efergy_728386').state)
self.assertEqual('1808', self.hass.states.get('sensor.efergy_0').state)
self.assertEqual('312', self.hass.states.get('sensor.efergy_728387').state)
|
'Initialize values for this testcase class.'
| def setUp(self):
| self.hass = get_test_home_assistant()
self.config = VALID_CONFIG
|
'Stop everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Test the default setup.'
| @patch('yahoo_finance.Base._request', return_value=json.loads(load_fixture('yahoo_finance.json')))
def test_default_setup(self, mock_request):
| with assert_setup_component(1, sensor.DOMAIN):
assert setup_component(self.hass, sensor.DOMAIN, {'sensor': VALID_CONFIG})
state = self.hass.states.get('sensor.yhoo')
self.assertEqual('41.69', state.attributes.get('open'))
self.assertEqual('41.79', state.attributes.get('prev_close'))
self.assertEqual('YHOO', state.attributes.get('unit_of_measurement'))
|
'Setup things to be run when tests are started.'
| def setUp(self):
| self.hass = get_test_home_assistant()
mock_component(self.hass, 'rfxtrx')
|
'Stop everything that was started.'
| def tearDown(self):
| rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS = []
rfxtrx_core.RFX_DEVICES = {}
if rfxtrx_core.RFXOBJECT:
rfxtrx_core.RFXOBJECT.close_connection()
self.hass.stop()
|
'Test with 0 sensor.'
| def test_default_config(self):
| self.assertTrue(setup_component(self.hass, 'sensor', {'sensor': {'platform': 'rfxtrx', 'devices': {}}}))
self.assertEqual(0, len(rfxtrx_core.RFX_DEVICES))
|
'Test with 1 sensor.'
| def test_old_config_sensor(self):
| self.assertTrue(setup_component(self.hass, 'sensor', {'sensor': {'platform': 'rfxtrx', 'devices': {'sensor_0502': {'name': 'Test', 'packetid': '0a52080705020095220269', 'data_type': 'Temperature'}}}}))
self.assertEqual(1, len(rfxtrx_core.RFX_DEVICES))
entity = rfxtrx_core.RFX_DEVICES['sensor_0502']['Temperature']
self.assertEqual('Test', entity.name)
self.assertEqual(TEMP_CELSIUS, entity.unit_of_measurement)
self.assertEqual(None, entity.state)
|
'Test with 1 sensor.'
| def test_one_sensor(self):
| self.assertTrue(setup_component(self.hass, 'sensor', {'sensor': {'platform': 'rfxtrx', 'devices': {'0a52080705020095220269': {'name': 'Test', 'data_type': 'Temperature'}}}}))
self.assertEqual(1, len(rfxtrx_core.RFX_DEVICES))
entity = rfxtrx_core.RFX_DEVICES['sensor_0502']['Temperature']
self.assertEqual('Test', entity.name)
self.assertEqual(TEMP_CELSIUS, entity.unit_of_measurement)
self.assertEqual(None, entity.state)
|
'Test with 1 sensor.'
| def test_one_sensor_no_datatype(self):
| self.assertTrue(setup_component(self.hass, 'sensor', {'sensor': {'platform': 'rfxtrx', 'devices': {'0a52080705020095220269': {'name': 'Test'}}}}))
self.assertEqual(1, len(rfxtrx_core.RFX_DEVICES))
entity = rfxtrx_core.RFX_DEVICES['sensor_0502']['Temperature']
self.assertEqual('Test', entity.name)
self.assertEqual(TEMP_CELSIUS, entity.unit_of_measurement)
self.assertEqual(None, entity.state)
entity_id = rfxtrx_core.RFX_DEVICES['sensor_0502']['Temperature'].entity_id
entity = self.hass.states.get(entity_id)
self.assertEqual('Test', entity.name)
self.assertEqual('unknown', entity.state)
|
'Test with 3 sensors.'
| def test_several_sensors(self):
| self.assertTrue(setup_component(self.hass, 'sensor', {'sensor': {'platform': 'rfxtrx', 'devices': {'0a52080705020095220269': {'name': 'Test', 'data_type': 'Temperature'}, '0a520802060100ff0e0269': {'name': 'Bath', 'data_type': ['Temperature', 'Humidity']}}}}))
self.assertEqual(2, len(rfxtrx_core.RFX_DEVICES))
device_num = 0
for id in rfxtrx_core.RFX_DEVICES:
if (id == 'sensor_0601'):
device_num = (device_num + 1)
self.assertEqual(len(rfxtrx_core.RFX_DEVICES[id]), 2)
_entity_temp = rfxtrx_core.RFX_DEVICES[id]['Temperature']
_entity_hum = rfxtrx_core.RFX_DEVICES[id]['Humidity']
self.assertEqual('%', _entity_hum.unit_of_measurement)
self.assertEqual('Bath', _entity_hum.__str__())
self.assertEqual(None, _entity_hum.state)
self.assertEqual(TEMP_CELSIUS, _entity_temp.unit_of_measurement)
self.assertEqual('Bath', _entity_temp.__str__())
elif (id == 'sensor_0502'):
device_num = (device_num + 1)
entity = rfxtrx_core.RFX_DEVICES[id]['Temperature']
self.assertEqual(None, entity.state)
self.assertEqual(TEMP_CELSIUS, entity.unit_of_measurement)
self.assertEqual('Test', entity.__str__())
self.assertEqual(2, device_num)
|
'Test with discovery of sensor.'
| def test_discover_sensor(self):
| self.assertTrue(setup_component(self.hass, 'sensor', {'sensor': {'platform': 'rfxtrx', 'automatic_add': True, 'devices': {}}}))
event = rfxtrx_core.get_rfx_object('0a520801070100b81b0279')
event.data = bytearray('\nR\x08\x01\x07\x01\x00\xb8\x1b\x02y')
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
entity = rfxtrx_core.RFX_DEVICES['sensor_0701']['Temperature']
self.assertEqual(1, len(rfxtrx_core.RFX_DEVICES))
self.assertEqual({'Humidity status': 'normal', 'Temperature': 18.4, 'Rssi numeric': 7, 'Humidity': 27, 'Battery numeric': 9, 'Humidity status numeric': 2}, entity.device_state_attributes)
self.assertEqual('0a520801070100b81b0279', entity.__str__())
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
self.assertEqual(1, len(rfxtrx_core.RFX_DEVICES))
event = rfxtrx_core.get_rfx_object('0a52080405020095240279')
event.data = bytearray('\nR\x08\x04\x05\x02\x00\x95$\x02y')
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
entity = rfxtrx_core.RFX_DEVICES['sensor_0502']['Temperature']
self.assertEqual(2, len(rfxtrx_core.RFX_DEVICES))
self.assertEqual({'Humidity status': 'normal', 'Temperature': 14.9, 'Rssi numeric': 7, 'Humidity': 36, 'Battery numeric': 9, 'Humidity status numeric': 2}, entity.device_state_attributes)
self.assertEqual('0a52080405020095240279', entity.__str__())
event = rfxtrx_core.get_rfx_object('0a52085e070100b31b0279')
event.data = bytearray('\nR\x08^\x07\x01\x00\xb3\x1b\x02y')
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
entity = rfxtrx_core.RFX_DEVICES['sensor_0701']['Temperature']
self.assertEqual(2, len(rfxtrx_core.RFX_DEVICES))
self.assertEqual({'Humidity status': 'normal', 'Temperature': 17.9, 'Rssi numeric': 7, 'Humidity': 27, 'Battery numeric': 9, 'Humidity status numeric': 2}, entity.device_state_attributes)
self.assertEqual('0a520801070100b81b0279', entity.__str__())
event = rfxtrx_core.get_rfx_object('0b1100cd0213c7f210010f70')
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
self.assertEqual(2, len(rfxtrx_core.RFX_DEVICES))
|
'Test with discover of sensor when auto add is False.'
| def test_discover_sensor_noautoadd(self):
| self.assertTrue(setup_component(self.hass, 'sensor', {'sensor': {'platform': 'rfxtrx', 'automatic_add': False, 'devices': {}}}))
event = rfxtrx_core.get_rfx_object('0a520801070100b81b0279')
event.data = bytearray('\nR\x08\x01\x07\x01\x00\xb8\x1b\x02y')
self.assertEqual(0, len(rfxtrx_core.RFX_DEVICES))
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
self.assertEqual(0, len(rfxtrx_core.RFX_DEVICES))
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
self.assertEqual(0, len(rfxtrx_core.RFX_DEVICES))
event = rfxtrx_core.get_rfx_object('0a52080405020095240279')
event.data = bytearray('\nR\x08\x04\x05\x02\x00\x95$\x02y')
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
self.assertEqual(0, len(rfxtrx_core.RFX_DEVICES))
event = rfxtrx_core.get_rfx_object('0a52085e070100b31b0279')
event.data = bytearray('\nR\x08^\x07\x01\x00\xb3\x1b\x02y')
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
self.assertEqual(0, len(rfxtrx_core.RFX_DEVICES))
|
'Test with 3 sensors.'
| def test_update_of_sensors(self):
| self.assertTrue(setup_component(self.hass, 'sensor', {'sensor': {'platform': 'rfxtrx', 'devices': {'0a52080705020095220269': {'name': 'Test', 'data_type': 'Temperature'}, '0a520802060100ff0e0269': {'name': 'Bath', 'data_type': ['Temperature', 'Humidity']}}}}))
self.assertEqual(2, len(rfxtrx_core.RFX_DEVICES))
device_num = 0
for id in rfxtrx_core.RFX_DEVICES:
if (id == 'sensor_0601'):
device_num = (device_num + 1)
self.assertEqual(len(rfxtrx_core.RFX_DEVICES[id]), 2)
_entity_temp = rfxtrx_core.RFX_DEVICES[id]['Temperature']
_entity_hum = rfxtrx_core.RFX_DEVICES[id]['Humidity']
self.assertEqual('%', _entity_hum.unit_of_measurement)
self.assertEqual('Bath', _entity_hum.__str__())
self.assertEqual(None, _entity_temp.state)
self.assertEqual(TEMP_CELSIUS, _entity_temp.unit_of_measurement)
self.assertEqual('Bath', _entity_temp.__str__())
elif (id == 'sensor_0502'):
device_num = (device_num + 1)
entity = rfxtrx_core.RFX_DEVICES[id]['Temperature']
self.assertEqual(None, entity.state)
self.assertEqual(TEMP_CELSIUS, entity.unit_of_measurement)
self.assertEqual('Test', entity.__str__())
self.assertEqual(2, device_num)
event = rfxtrx_core.get_rfx_object('0a520802060101ff0f0269')
event.data = bytearray('\nR\x08\x01\x07\x01\x00\xb8\x1b\x02y')
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
event = rfxtrx_core.get_rfx_object('0a52080705020085220269')
event.data = bytearray('\nR\x08\x04\x05\x02\x00\x95$\x02y')
rfxtrx_core.RECEIVED_EVT_SUBSCRIBERS[0](event)
self.assertEqual(2, len(rfxtrx_core.RFX_DEVICES))
device_num = 0
for id in rfxtrx_core.RFX_DEVICES:
if (id == 'sensor_0601'):
device_num = (device_num + 1)
self.assertEqual(len(rfxtrx_core.RFX_DEVICES[id]), 2)
_entity_temp = rfxtrx_core.RFX_DEVICES[id]['Temperature']
_entity_hum = rfxtrx_core.RFX_DEVICES[id]['Humidity']
self.assertEqual('%', _entity_hum.unit_of_measurement)
self.assertEqual(15, _entity_hum.state)
self.assertEqual({'Battery numeric': 9, 'Temperature': 51.1, 'Humidity': 15, 'Humidity status': 'normal', 'Humidity status numeric': 2, 'Rssi numeric': 6}, _entity_hum.device_state_attributes)
self.assertEqual('Bath', _entity_hum.__str__())
self.assertEqual(TEMP_CELSIUS, _entity_temp.unit_of_measurement)
self.assertEqual(51.1, _entity_temp.state)
self.assertEqual({'Battery numeric': 9, 'Temperature': 51.1, 'Humidity': 15, 'Humidity status': 'normal', 'Humidity status numeric': 2, 'Rssi numeric': 6}, _entity_temp.device_state_attributes)
self.assertEqual('Bath', _entity_temp.__str__())
elif (id == 'sensor_0502'):
device_num = (device_num + 1)
entity = rfxtrx_core.RFX_DEVICES[id]['Temperature']
self.assertEqual(TEMP_CELSIUS, entity.unit_of_measurement)
self.assertEqual(13.3, entity.state)
self.assertEqual({'Humidity status': 'normal', 'Temperature': 13.3, 'Rssi numeric': 6, 'Humidity': 34, 'Battery numeric': 9, 'Humidity status numeric': 2}, entity.device_state_attributes)
self.assertEqual('Test', entity.__str__())
self.assertEqual(2, device_num)
self.assertEqual(2, len(rfxtrx_core.RFX_DEVICES))
|
'Setup things to be run when tests are started.'
| def setup_method(self, method):
| self.hass = get_test_home_assistant()
|
'Stop everything that was started.'
| def teardown_method(self, method):
| self.hass.stop()
|
'Test setup with missing configuration.'
| @mock.patch('mficlient.client.MFiClient')
def test_setup_missing_config(self, mock_client):
| config = {'sensor': {'platform': 'mfi'}}
assert setup_component(self.hass, 'sensor', config)
assert (not mock_client.called)
|
'Test setup with login failure.'
| @mock.patch('mficlient.client.MFiClient')
def test_setup_failed_login(self, mock_client):
| from mficlient.client import FailedToLogin
mock_client.side_effect = FailedToLogin
self.assertFalse(self.PLATFORM.setup_platform(self.hass, dict(self.GOOD_CONFIG), None))
|
'Test setup with conection failure.'
| @mock.patch('mficlient.client.MFiClient')
def test_setup_failed_connect(self, mock_client):
| mock_client.side_effect = requests.exceptions.ConnectionError
self.assertFalse(self.PLATFORM.setup_platform(self.hass, dict(self.GOOD_CONFIG), None))
|
'Test setup with minimum configuration.'
| @mock.patch('mficlient.client.MFiClient')
def test_setup_minimum(self, mock_client):
| config = dict(self.GOOD_CONFIG)
del config[self.THING]['port']
assert setup_component(self.hass, self.COMPONENT.DOMAIN, config)
self.assertEqual(mock_client.call_count, 1)
self.assertEqual(mock_client.call_args, mock.call('foo', 'user', 'pass', port=6443, use_tls=True, verify=True))
|
'Test setup with port.'
| @mock.patch('mficlient.client.MFiClient')
def test_setup_with_port(self, mock_client):
| config = dict(self.GOOD_CONFIG)
config[self.THING]['port'] = 6123
assert setup_component(self.hass, self.COMPONENT.DOMAIN, config)
self.assertEqual(mock_client.call_count, 1)
self.assertEqual(mock_client.call_args, mock.call('foo', 'user', 'pass', port=6123, use_tls=True, verify=True))
|
'Test setup without TLS.'
| @mock.patch('mficlient.client.MFiClient')
def test_setup_with_tls_disabled(self, mock_client):
| config = dict(self.GOOD_CONFIG)
del config[self.THING]['port']
config[self.THING]['ssl'] = False
config[self.THING]['verify_ssl'] = False
assert setup_component(self.hass, self.COMPONENT.DOMAIN, config)
self.assertEqual(mock_client.call_count, 1)
self.assertEqual(mock_client.call_args, mock.call('foo', 'user', 'pass', port=6080, use_tls=False, verify=False))
|
'Test if setup adds devices.'
| @mock.patch('mficlient.client.MFiClient')
@mock.patch('homeassistant.components.sensor.mfi.MfiSensor')
def test_setup_adds_proper_devices(self, mock_sensor, mock_client):
| ports = {i: mock.MagicMock(model=model) for (i, model) in enumerate(mfi.SENSOR_MODELS)}
ports['bad'] = mock.MagicMock(model='notasensor')
mock_client.return_value.get_devices.return_value = [mock.MagicMock(ports=ports)]
assert setup_component(self.hass, sensor.DOMAIN, self.GOOD_CONFIG)
for (ident, port) in ports.items():
if (ident != 'bad'):
mock_sensor.assert_any_call(port, self.hass)
assert (mock.call(ports['bad'], self.hass) not in mock_sensor.mock_calls)
|
'Setup things to be run when tests are started.'
| def setup_method(self, method):
| self.hass = get_test_home_assistant()
self.port = mock.MagicMock()
self.sensor = mfi.MfiSensor(self.port, self.hass)
|
'Stop everything that was started.'
| def teardown_method(self, method):
| self.hass.stop()
|
'Test the name.'
| def test_name(self):
| self.assertEqual(self.port.label, self.sensor.name)
|
'Test the UOM temperature.'
| def test_uom_temp(self):
| self.port.tag = 'temperature'
self.assertEqual(TEMP_CELSIUS, self.sensor.unit_of_measurement)
|
'Test the UOEM power.'
| def test_uom_power(self):
| self.port.tag = 'active_pwr'
self.assertEqual('Watts', self.sensor.unit_of_measurement)
|
'Test the UOM digital input.'
| def test_uom_digital(self):
| self.port.model = 'Input Digital'
self.assertEqual('State', self.sensor.unit_of_measurement)
|
'Test the UOM.'
| def test_uom_unknown(self):
| self.port.tag = 'balloons'
self.assertEqual('balloons', self.sensor.unit_of_measurement)
|
'Test that the UOM defaults if not initialized.'
| def test_uom_uninitialized(self):
| type(self.port).tag = mock.PropertyMock(side_effect=ValueError)
self.assertEqual('State', self.sensor.unit_of_measurement)
|
'Test the digital input.'
| def test_state_digital(self):
| self.port.model = 'Input Digital'
self.port.value = 0
self.assertEqual(mfi.STATE_OFF, self.sensor.state)
self.port.value = 1
self.assertEqual(mfi.STATE_ON, self.sensor.state)
self.port.value = 2
self.assertEqual(mfi.STATE_ON, self.sensor.state)
|
'Test the state of digits.'
| def test_state_digits(self):
| self.port.tag = 'didyoucheckthedict?'
self.port.value = 1.25
with mock.patch.dict(mfi.DIGITS, {'didyoucheckthedict?': 1}):
self.assertEqual(1.2, self.sensor.state)
with mock.patch.dict(mfi.DIGITS, {}):
self.assertEqual(1.0, self.sensor.state)
|
'Test the state of uninitialized sensors.'
| def test_state_uninitialized(self):
| type(self.port).tag = mock.PropertyMock(side_effect=ValueError)
self.assertEqual(mfi.STATE_OFF, self.sensor.state)
|
'Test the update.'
| def test_update(self):
| self.sensor.update()
self.assertEqual(self.port.refresh.call_count, 1)
self.assertEqual(self.port.refresh.call_args, mock.call())
|
'Mock add devices.'
| def add_devices(self, devices):
| for device in devices:
self.DEVICES.append(device)
|
'Initialize values for this testcase class.'
| def setUp(self):
| self.DEVICES = []
self.hass = get_test_home_assistant()
self.key = 'foo'
self.config = VALID_CONFIG_PWS
self.lat = 37.8267
self.lon = (-122.423)
self.hass.config.latitude = self.lat
self.hass.config.longitude = self.lon
|
'Stop everything that was started.'
| def tearDown(self):
| self.hass.stop()
|
'Test that the component is loaded if passed in PWS Id.'
| @unittest.mock.patch('requests.get', side_effect=mocked_requests_get)
def test_setup(self, req_mock):
| self.assertTrue(wunderground.setup_platform(self.hass, VALID_CONFIG_PWS, self.add_devices, None))
self.assertTrue(wunderground.setup_platform(self.hass, VALID_CONFIG, self.add_devices, None))
self.assertTrue(wunderground.setup_platform(self.hass, INVALID_CONFIG, self.add_devices, None))
|
'Test the WUnderground sensor class and methods.'
| @unittest.mock.patch('requests.get', side_effect=mocked_requests_get)
def test_sensor(self, req_mock):
| wunderground.setup_platform(self.hass, VALID_CONFIG, self.add_devices, None)
for device in self.DEVICES:
device.update()
self.assertTrue(str(device.name).startswith('PWS_'))
if (device.name == 'PWS_weather'):
self.assertEqual(HTTPS_ICON_URL, device.entity_picture)
self.assertEqual(WEATHER, device.state)
self.assertIsNone(device.unit_of_measurement)
elif (device.name == 'PWS_alerts'):
self.assertEqual(1, device.state)
self.assertEqual(ALERT_MESSAGE, device.device_state_attributes['Message'])
self.assertIsNone(device.entity_picture)
elif (device.name == 'PWS_location'):
self.assertEqual('Holly Springs, NC', device.state)
elif (device.name == 'PWS_elevation'):
self.assertEqual('413', device.state)
elif (device.name == 'PWS_feelslike_c'):
self.assertIsNone(device.entity_picture)
self.assertEqual(FEELS_LIKE, device.state)
self.assertEqual(TEMP_CELSIUS, device.unit_of_measurement)
elif (device.name == 'PWS_weather_1d_metric'):
self.assertEqual(FORECAST_TEXT, device.state)
else:
self.assertEqual(device.name, 'PWS_precip_1d_in')
self.assertEqual(PRECIP_IN, device.state)
self.assertEqual(LENGTH_INCHES, device.unit_of_measurement)
|
'Mock add devices.'
| def add_devices(self, devices, action):
| for device in devices:
self.DEVICES.append(device)
|
'Cleanup any data created from the tests.'
| def cleanup(self):
| if os.path.isfile(self.cache):
os.remove(self.cache)
|
'Initialize values for this testcase class.'
| def setUp(self):
| self.hass = get_test_home_assistant()
self.cache = get_test_config_dir(base_ring.DEFAULT_CACHEDB)
self.config = {'username': 'foo', 'password': 'bar', 'monitored_conditions': ['battery', 'last_activity', 'last_ding', 'last_motion', 'volume']}
|
'Stop everything that was started.'
| def tearDown(self):
| self.hass.stop()
self.cleanup()
|
'Test the Ring senskor class and methods.'
| @requests_mock.Mocker()
def test_sensor(self, mock):
| mock.post('https://api.ring.com/clients_api/session', text=load_fixture('ring_session.json'))
mock.get('https://api.ring.com/clients_api/ring_devices', text=load_fixture('ring_devices.json'))
mock.get('https://api.ring.com/clients_api/doorbots/987652/history', text=load_fixture('ring_doorbots.json'))
base_ring.setup(self.hass, VALID_CONFIG)
ring.setup_platform(self.hass, self.config, self.add_devices, None)
for device in self.DEVICES:
device.update()
if (device.name == 'Front Door Battery'):
self.assertEqual(100, device.state)
self.assertEqual('lpd_v1', device.device_state_attributes['kind'])
self.assertNotEqual('chimes', device.device_state_attributes['type'])
if (device.name == 'Downstairs Volume'):
self.assertEqual(2, device.state)
self.assertEqual('1.2.3', device.device_state_attributes['firmware'])
self.assertEqual('mdi:bell-ring', device.icon)
self.assertEqual('chimes', device.device_state_attributes['type'])
if (device.name == 'Front Door Last Activity'):
self.assertFalse(device.device_state_attributes['answered'])
self.assertEqual('America/New_York', device.device_state_attributes['timezone'])
self.assertIsNone(device.entity_picture)
self.assertEqual(ATTRIBUTION, device.device_state_attributes['attribution'])
|
'Set up things to be run when tests are started.'
| def setup_method(self, method):
| self.hass = get_test_home_assistant()
|
'Stop everything that was started.'
| def teardown_method(self, method):
| self.hass.stop()
|
'Test the File sensor.'
| @patch('os.path.isfile', Mock(return_value=True))
@patch('os.access', Mock(return_value=True))
def test_file_value(self):
| config = {'sensor': {'platform': 'file', 'name': 'file1', 'file_path': 'mock.file1'}}
m_open = MockOpen(read_data='43\n45\n21')
with patch('homeassistant.components.sensor.file.open', m_open, create=True):
assert setup_component(self.hass, 'sensor', config)
self.hass.block_till_done()
state = self.hass.states.get('sensor.file1')
self.assertEqual(state.state, '21')
|
'Test the File sensor with JSON entries.'
| @patch('os.path.isfile', Mock(return_value=True))
@patch('os.access', Mock(return_value=True))
def test_file_value_template(self):
| config = {'sensor': {'platform': 'file', 'name': 'file2', 'file_path': 'mock.file2', 'value_template': '{{ value_json.temperature }}'}}
data = '{"temperature": 29, "humidity": 31}\n{"temperature": 26, "humidity": 36}'
m_open = MockOpen(read_data=data)
with patch('homeassistant.components.sensor.file.open', m_open, create=True):
assert setup_component(self.hass, 'sensor', config)
self.hass.block_till_done()
state = self.hass.states.get('sensor.file2')
self.assertEqual(state.state, '26')
|
'Test the File sensor with an empty file.'
| @patch('os.path.isfile', Mock(return_value=True))
@patch('os.access', Mock(return_value=True))
def test_file_empty(self):
| config = {'sensor': {'platform': 'file', 'name': 'file3', 'file_path': 'mock.file'}}
m_open = MockOpen(read_data='')
with patch('homeassistant.components.sensor.file.open', m_open, create=True):
assert setup_component(self.hass, 'sensor', config)
self.hass.block_till_done()
state = self.hass.states.get('sensor.file3')
self.assertEqual(state.state, STATE_UNKNOWN)
|
'Setup the fake email reader.'
| def __init__(self, messages):
| self._messages = messages
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.