evlli/hass-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Replacing tempfile with mock_open in tests (#3753)

Browse source 
- test_bootstrap.py
- test_config.py
- components/test_init.py
- components/test_panel_custom.py
- components/test_api.py
- components/notify/test_file.py
- components/notify/test_demo.py
- components/camera/test_local_file.py
- helpers/test_config_validation.py
- util/test_package.py
- util/test_yaml.py

No changes needed in:
- components/cover/test_command_line.py
- components/switch/test_command_line.py
- components/rollershutter/test_command_line.py
- components/test_shell_command.py
- components/notify/test_command_line.py

Misc changes in:
- components/mqtt/test_server.py

Also, removed some unused mock parameters in tests/components/mqtt/test_server.py.
This commit is contained in:
Rob Capellini 2016-10-17 23:16:36 -04:00 • committed by Paulus Schoutsen
parent 7d67017de7
commit 272539105f
12 changed files with 403 additions and 335 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

44
tests/components/camera/test_local_file.py
View file

@ -1,5 +1,4 @@
"""The tests for local file camera component."""
from tempfile import NamedTemporaryFile
import unittest
from unittest import mock
@ -26,45 +25,46 @@ class TestLocalCamera(unittest.TestCase):
def test_loading_file(self):
"""Test that it loads image from disk."""
test_string = 'hello'
self.hass.wsgi = mock.MagicMock()
with NamedTemporaryFile() as fptr:
fptr.write('hello'.encode('utf-8'))
fptr.flush()
with mock.patch('os.path.isfile', mock.Mock(return_value=True)), \
mock.patch('os.access', mock.Mock(return_value=True)):
assert setup_component(self.hass, 'camera', {
'camera': {
'name': 'config_test',
'platform': 'local_file',
'file_path': fptr.name,
'file_path': 'mock.file',
}})
image_view = self.hass.wsgi.mock_calls[0][1][0]
image_view = self.hass.wsgi.mock_calls[0][1][0]
m_open = mock.mock_open(read_data=test_string)
with mock.patch(
'homeassistant.components.camera.local_file.open',
m_open, create=True
):
builder = EnvironBuilder(method='GET')
Request = request_class() # pylint: disable=invalid-name
request = Request(builder.get_environ())
request.authenticated = True
resp = image_view.get(request, 'camera.config_test')
assert resp.status_code == 200, resp.response
assert resp.response[0].decode('utf-8') == 'hello'
assert resp.status_code == 200, resp.response
assert resp.response[0].decode('utf-8') == test_string
def test_file_not_readable(self):
"""Test local file will not setup when file is not readable."""
self.hass.wsgi = mock.MagicMock()
with NamedTemporaryFile() as fptr:
fptr.write('hello'.encode('utf-8'))
fptr.flush()
with mock.patch('os.path.isfile', mock.Mock(return_value=True)), \
mock.patch('os.access', return_value=False), \
assert_setup_component(0):
assert setup_component(self.hass, 'camera', {
'camera': {
'name': 'config_test',
'platform': 'local_file',
'file_path': 'mock.file',
}})
with mock.patch('os.access', return_value=False), \
assert_setup_component(0):
assert setup_component(self.hass, 'camera', {
'camera': {
'name': 'config_test',
'platform': 'local_file',
'file_path': fptr.name,
}})
assert [] == self.hass.states.all()
assert [] == self.hass.states.all()

18
tests/components/mqtt/test_server.py
View file

@ -1,5 +1,5 @@
"""The tests for the MQTT component embedded server."""
from unittest.mock import MagicMock, patch
from unittest.mock import Mock, MagicMock, patch
from homeassistant.bootstrap import _setup_component
import homeassistant.components.mqtt as mqtt
@ -18,14 +18,12 @@ class TestMQTT:
"""Stop everything that was started."""
self.hass.stop()
@patch('passlib.apps.custom_app_context', return_value='')
@patch('tempfile.NamedTemporaryFile', return_value=MagicMock())
@patch('passlib.apps.custom_app_context', Mock(return_value=''))
@patch('tempfile.NamedTemporaryFile', Mock(return_value=MagicMock()))
@patch('asyncio.new_event_loop', Mock())
@patch('homeassistant.components.mqtt.MQTT')
@patch('asyncio.gather')
@patch('asyncio.new_event_loop')
def test_creating_config_with_http_pass(self, mock_new_loop, mock_gather,
mock_mqtt, mock_temp,
mock_context):
def test_creating_config_with_http_pass(self, mock_gather, mock_mqtt):
"""Test if the MQTT server gets started and subscribe/publish msg."""
self.hass.config.components.append('http')
password = 'super_secret'
@ -45,10 +43,10 @@ class TestMQTT:
assert mock_mqtt.mock_calls[0][1][5] is None
assert mock_mqtt.mock_calls[0][1][6] is None
@patch('tempfile.NamedTemporaryFile', return_value=MagicMock())
@patch('tempfile.NamedTemporaryFile', Mock(return_value=MagicMock()))
@patch('asyncio.new_event_loop', Mock())
@patch('asyncio.gather')
@patch('asyncio.new_event_loop')
def test_broker_config_fails(self, mock_new_loop, mock_gather, mock_temp):
def test_broker_config_fails(self, mock_gather):
"""Test if the MQTT component fails if server fails."""
self.hass.config.components.append('http')
from hbmqtt.broker import BrokerException

60
tests/components/notify/test_demo.py
View file

@ -1,12 +1,10 @@
"""The tests for the notify demo platform."""
import tempfile
import unittest
from homeassistant.bootstrap import setup_component
import homeassistant.components.notify as notify
from homeassistant.components.notify import demo
from homeassistant.helpers import script
from homeassistant.util import yaml
from tests.common import get_test_home_assistant
@ -70,21 +68,18 @@ class TestNotifyDemo(unittest.TestCase):
def test_calling_notify_from_script_loaded_from_yaml_without_title(self):
"""Test if we can call a notify from a script."""
yaml_conf = """
service: notify.notify
data:
data:
push:
sound: US-EN-Morgan-Freeman-Roommate-Is-Arriving.wav
data_template:
message: >
Test 123 {{ 2 + 2 }}
"""
with tempfile.NamedTemporaryFile() as fp:
fp.write(yaml_conf.encode('utf-8'))
fp.flush()
conf = yaml.load_yaml(fp.name)
conf = {
'service': 'notify.notify',
'data': {
'data': {
'push': {
'sound':
'US-EN-Morgan-Freeman-Roommate-Is-Arriving.wav'
}
}
},
'data_template': {'message': 'Test 123 {{ 2 + 2 }}\n'},
}
script.call_from_config(self.hass, conf)
self.hass.block_till_done()
@ -99,22 +94,21 @@ data_template:
def test_calling_notify_from_script_loaded_from_yaml_with_title(self):
"""Test if we can call a notify from a script."""
yaml_conf = """
service: notify.notify
data:
data:
push:
sound: US-EN-Morgan-Freeman-Roommate-Is-Arriving.wav
data_template:
title: Test
message: >
Test 123 {{ 2 + 2 }}
"""
with tempfile.NamedTemporaryFile() as fp:
fp.write(yaml_conf.encode('utf-8'))
fp.flush()
conf = yaml.load_yaml(fp.name)
conf = {
'service': 'notify.notify',
'data': {
'data': {
'push': {
'sound':
'US-EN-Morgan-Freeman-Roommate-Is-Arriving.wav'
}
}
},
'data_template': {
'message': 'Test 123 {{ 2 + 2 }}\n',
'title': 'Test'
}
}
script.call_from_config(self.hass, conf)
self.hass.pool.block_till_done()

26
tests/components/notify/test_file.py
View file

@ -1,8 +1,7 @@
"""The tests for the notify file platform."""
import os
import unittest
import tempfile
from unittest.mock import patch
from unittest.mock import call, mock_open, patch
from homeassistant.bootstrap import setup_component
import homeassistant.components.notify as notify
@ -34,13 +33,19 @@ class TestNotifyFile(unittest.TestCase):
},
}))
@patch('homeassistant.components.notify.file.os.stat')
@patch('homeassistant.util.dt.utcnow')
def test_notify_file(self, mock_utcnow):
def test_notify_file(self, mock_utcnow, mock_stat):
"""Test the notify file output."""
mock_utcnow.return_value = dt_util.as_utc(dt_util.now())
mock_stat.return_value.st_size = 0
with tempfile.TemporaryDirectory() as tempdirname:
filename = os.path.join(tempdirname, 'notify.txt')
m_open = mock_open()
with patch(
'homeassistant.components.notify.file.open',
m_open, create=True
):
filename = 'mock_file'
message = 'one, two, testing, testing'
self.assertTrue(setup_component(self.hass, notify.DOMAIN, {
'notify': {
@ -58,5 +63,12 @@ class TestNotifyFile(unittest.TestCase):
self.hass.services.call('notify', 'test', {'message': message},
blocking=True)
result = open(filename).read()
self.assertEqual(result, "{}{}\n".format(title, message))
full_filename = os.path.join(self.hass.config.path(), filename)
self.assertEqual(m_open.call_count, 1)
self.assertEqual(m_open.call_args, call(full_filename, 'a'))
self.assertEqual(m_open.return_value.write.call_count, 2)
self.assertEqual(
m_open.return_value.write.call_args_list,
[call(title), call(message + '\n')]
)

24
tests/components/test_api.py
View file

@ -2,10 +2,9 @@
# pylint: disable=protected-access,too-many-public-methods
from contextlib import closing
import json
import tempfile
import time
import unittest
from unittest.mock import patch
from unittest.mock import Mock, patch
import requests
@ -244,15 +243,20 @@ class TestAPI(unittest.TestCase):
def test_api_get_error_log(self):
"""Test the return of the error log."""
test_content = 'Test String°'
with tempfile.NamedTemporaryFile() as log:
log.write(test_content.encode('utf-8'))
log.flush()
test_string = 'Test String°'.encode('UTF-8')
with patch.object(hass.config, 'path', return_value=log.name):
req = requests.get(_url(const.URL_API_ERROR_LOG),
headers=HA_HEADERS)
self.assertEqual(test_content, req.text)
# Can't use read_data with wsgiserver in Python 3.4.2. Due to a
# bug in read_data, it can't handle byte types ('Type str doesn't
# support the buffer API'), but wsgiserver requires byte types
# ('WSGI Applications must yield bytes'). So just mock our own
# read method.
m_open = Mock(return_value=Mock(
read=Mock(side_effect=[test_string]))
)
with patch('homeassistant.components.http.open', m_open, create=True):
req = requests.get(_url(const.URL_API_ERROR_LOG),
headers=HA_HEADERS)
self.assertEqual(test_string, req.text.encode('UTF-8'))
self.assertIsNone(req.headers.get('expires'))
def test_api_get_event_listeners(self):

46
tests/components/test_init.py
View file

@ -1,8 +1,7 @@
"""The testd for Core components."""
# pylint: disable=protected-access,too-many-public-methods
import unittest
from unittest.mock import patch
from tempfile import TemporaryDirectory
from unittest.mock import patch, Mock
import yaml
@ -13,7 +12,8 @@ from homeassistant.const import (
import homeassistant.components as comps
from homeassistant.helpers import entity
from tests.common import get_test_home_assistant, mock_service
from tests.common import (
get_test_home_assistant, mock_service, patch_yaml_files)
class TestComponentsCore(unittest.TestCase):
@ -89,6 +89,7 @@ class TestComponentsCore(unittest.TestCase):
('sensor', 'turn_on', {'entity_id': ['sensor.bla']}, False),
mock_call.call_args_list[1][0])
@patch('homeassistant.config.os.path.isfile', Mock(return_value=True))
def test_reload_core_conf(self):
"""Test reload core conf service."""
ent = entity.Entity()
@ -101,23 +102,20 @@ class TestComponentsCore(unittest.TestCase):
assert state.state == 'unknown'
assert state.attributes == {}
with TemporaryDirectory() as conf_dir:
self.hass.config.config_dir = conf_dir
conf_yaml = self.hass.config.path(config.YAML_CONFIG_FILE)
with open(conf_yaml, 'a') as fp:
fp.write(yaml.dump({
ha.DOMAIN: {
'latitude': 10,
'longitude': 20,
'customize': {
'test.Entity': {
'hello': 'world'
}
files = {
config.YAML_CONFIG_FILE: yaml.dump({
ha.DOMAIN: {
'latitude': 10,
'longitude': 20,
'customize': {
'test.Entity': {
'hello': 'world'
}
}
}))
}
})
}
with patch_yaml_files(files, True):
comps.reload_core_config(self.hass)
self.hass.block_till_done()
@ -131,17 +129,15 @@ class TestComponentsCore(unittest.TestCase):
assert state.state == 'unknown'
assert state.attributes.get('hello') == 'world'
@patch('homeassistant.config.os.path.isfile', Mock(return_value=True))
@patch('homeassistant.components._LOGGER.error')
@patch('homeassistant.config.process_ha_core_config')
def test_reload_core_with_wrong_conf(self, mock_process, mock_error):
"""Test reload core conf service."""
with TemporaryDirectory() as conf_dir:
self.hass.config.config_dir = conf_dir
conf_yaml = self.hass.config.path(config.YAML_CONFIG_FILE)
with open(conf_yaml, 'a') as fp:
fp.write(yaml.dump(['invalid', 'config']))
files = {
config.YAML_CONFIG_FILE: yaml.dump(['invalid', 'config'])
}
with patch_yaml_files(files, True):
comps.reload_core_config(self.hass)
self.hass.block_till_done()

62
tests/components/test_panel_custom.py
View file

@ -1,9 +1,8 @@
"""The tests for the panel_custom component."""
import os
import shutil
from tempfile import NamedTemporaryFile
import unittest
from unittest.mock import patch
from unittest.mock import Mock, patch
from homeassistant import bootstrap
from homeassistant.components import panel_custom
@ -47,31 +46,40 @@ class TestPanelCustom(unittest.TestCase):
@patch('homeassistant.components.panel_custom.register_panel')
def test_webcomponent_custom_path(self, mock_register, _mock_setup):
"""Test if a web component is found in config panels dir."""
with NamedTemporaryFile() as fp:
config = {
'panel_custom': {
'name': 'todomvc',
'webcomponent_path': fp.name,
'sidebar_title': 'Sidebar Title',
'sidebar_icon': 'mdi:iconicon',
'url_path': 'nice_url',
'config': 5,
}
}
filename = 'mock.file'
with patch('os.path.isfile', return_value=False):
assert not bootstrap.setup_component(self.hass, 'panel_custom',
config)
assert not mock_register.called
assert bootstrap.setup_component(self.hass, 'panel_custom', config)
assert mock_register.called
args = mock_register.mock_calls[0][1]
kwargs = mock_register.mock_calls[0][2]
assert args == (self.hass, 'todomvc', fp.name)
assert kwargs == {
'config': 5,
'url_path': 'nice_url',
config = {
'panel_custom': {
'name': 'todomvc',
'webcomponent_path': filename,
'sidebar_title': 'Sidebar Title',
'sidebar_icon': 'mdi:iconicon',
'sidebar_title': 'Sidebar Title'
'url_path': 'nice_url',
'config': 5,
}
}
with patch('os.path.isfile', Mock(return_value=False)):
assert not bootstrap.setup_component(
self.hass, 'panel_custom', config
)
assert not mock_register.called
with patch('os.path.isfile', Mock(return_value=True)):
with patch('os.access', Mock(return_value=True)):
assert bootstrap.setup_component(
self.hass, 'panel_custom', config
)
assert mock_register.called
args = mock_register.mock_calls[0][1]
assert args == (self.hass, 'todomvc', filename)
kwargs = mock_register.mock_calls[0][2]
assert kwargs == {
'config': 5,
'url_path': 'nice_url',
'sidebar_icon': 'mdi:iconicon',
'sidebar_title': 'Sidebar Title'
}

18
tests/helpers/test_config_validation.py
View file

@ -3,10 +3,10 @@ from collections import OrderedDict
from datetime import timedelta
import enum
import os
import tempfile
import pytest
import voluptuous as vol
from unittest.mock import Mock, patch
import homeassistant.helpers.config_validation as cv
@ -68,18 +68,18 @@ def test_isfile():
"""Validate that the value is an existing file."""
schema = vol.Schema(cv.isfile)
with tempfile.NamedTemporaryFile() as fp:
pass
fake_file = 'this-file-does-not.exist'
assert not os.path.isfile(fake_file)
for value in ('invalid', None, -1, 0, 80000, fp.name):
for value in ('invalid', None, -1, 0, 80000, fake_file):
with pytest.raises(vol.Invalid):
schema(value)
with tempfile.TemporaryDirectory() as tmp_path:
tmp_file = os.path.join(tmp_path, "test.txt")
with open(tmp_file, "w") as tmp_handl:
tmp_handl.write("test file")
schema(tmp_file)
# patching methods that allow us to fake a file existing
# with write access
with patch('os.path.isfile', Mock(return_value=True)), \
patch('os.access', Mock(return_value=True)):
schema('test.txt')
def test_url():

24
tests/test_bootstrap.py
View file

@ -1,6 +1,5 @@
"""Test the bootstrapping."""
# pylint: disable=too-many-public-methods,protected-access
import tempfile
from unittest import mock
import threading
import logging
@ -12,7 +11,8 @@ import homeassistant.util.dt as dt_util
from homeassistant.helpers.config_validation import PLATFORM_SCHEMA
from tests.common import \
get_test_home_assistant, MockModule, MockPlatform, assert_setup_component
get_test_home_assistant, MockModule, MockPlatform, \
assert_setup_component, patch_yaml_files
ORIG_TIMEZONE = dt_util.DEFAULT_TIME_ZONE
@ -45,17 +45,27 @@ class TestBootstrap:
self.hass.stop()
loader._COMPONENT_CACHE = self.backup_cache
@mock.patch(
# prevent .HA_VERISON file from being written
'homeassistant.bootstrap.conf_util.process_ha_config_upgrade',
mock.Mock()
)
@mock.patch('homeassistant.util.location.detect_location_info',
return_value=None)
def test_from_config_file(self, mock_detect):
"""Test with configuration file."""
components = ['browser', 'conversation', 'script']
with tempfile.NamedTemporaryFile() as fp:
for comp in components:
fp.write('{}:\n'.format(comp).encode('utf-8'))
fp.flush()
files = {
'config.yaml': ''.join(
'{}:\n'.format(comp)
for comp in components
)
}
self.hass = bootstrap.from_config_file(fp.name)
with mock.patch('os.path.isfile', mock.Mock(return_value=True)), \
mock.patch('os.access', mock.Mock(return_value=True)), \
patch_yaml_files(files, True):
self.hass = bootstrap.from_config_file('config.yaml')
components.append('group')
assert sorted(components) == sorted(self.hass.config.components)

62
tests/test_config.py
View file

@ -1,7 +1,6 @@
"""Test config utils."""
# pylint: disable=too-many-public-methods,protected-access
import os
import tempfile
import unittest
import unittest.mock as mock
@ -212,49 +211,56 @@ class TestConfig(unittest.TestCase):
assert state.attributes['hidden']
def test_remove_lib_on_upgrade(self):
@mock.patch('homeassistant.config.shutil')
@mock.patch('homeassistant.config.os')
def test_remove_lib_on_upgrade(self, mock_os, mock_shutil):
"""Test removal of library on upgrade."""
with tempfile.TemporaryDirectory() as config_dir:
version_path = os.path.join(config_dir, '.HA_VERSION')
lib_dir = os.path.join(config_dir, 'deps')
check_file = os.path.join(lib_dir, 'check')
ha_version = '0.7.0'
with open(version_path, 'wt') as outp:
outp.write('0.7.0')
mock_os.path.isdir = mock.Mock(return_value=True)
os.mkdir(lib_dir)
with open(check_file, 'w'):
pass
mock_open = mock.mock_open()
with mock.patch('homeassistant.config.open', mock_open, create=True):
opened_file = mock_open.return_value
opened_file.readline.return_value = ha_version
self.hass = get_test_home_assistant()
self.hass.config.config_dir = config_dir
self.hass.config.path = mock.Mock()
assert os.path.isfile(check_file)
config_util.process_ha_config_upgrade(self.hass)
assert not os.path.isfile(check_file)
def test_not_remove_lib_if_not_upgrade(self):
hass_path = self.hass.config.path.return_value
self.assertEqual(mock_os.path.isdir.call_count, 1)
self.assertEqual(
mock_os.path.isdir.call_args, mock.call(hass_path)
)
self.assertEqual(mock_shutil.rmtree.call_count, 1)
self.assertEqual(
mock_shutil.rmtree.call_args, mock.call(hass_path)
)
@mock.patch('homeassistant.config.shutil')
@mock.patch('homeassistant.config.os')
def test_not_remove_lib_if_not_upgrade(self, mock_os, mock_shutil):
"""Test removal of library with no upgrade."""
with tempfile.TemporaryDirectory() as config_dir:
version_path = os.path.join(config_dir, '.HA_VERSION')
lib_dir = os.path.join(config_dir, 'deps')
check_file = os.path.join(lib_dir, 'check')
ha_version = __version__
with open(version_path, 'wt') as outp:
outp.write(__version__)
mock_os.path.isdir = mock.Mock(return_value=True)
os.mkdir(lib_dir)
with open(check_file, 'w'):
pass
mock_open = mock.mock_open()
with mock.patch('homeassistant.config.open', mock_open, create=True):
opened_file = mock_open.return_value
opened_file.readline.return_value = ha_version
self.hass = get_test_home_assistant()
self.hass.config.config_dir = config_dir
self.hass.config.path = mock.Mock()
config_util.process_ha_config_upgrade(self.hass)
assert os.path.isfile(check_file)
assert mock_os.path.isdir.call_count == 0
assert mock_shutil.rmtree.call_count == 0
def test_loading_configuration(self):
"""Test loading core config onto hass object."""

138
tests/util/test_package.py
View file

@ -1,9 +1,12 @@
"""Test Home Assistant package util methods."""
import os
import tempfile
import pkg_resources
import subprocess
import unittest
from homeassistant.bootstrap import mount_local_lib_path
from distutils.sysconfig import get_python_lib
from unittest.mock import call, patch
import homeassistant.util.package as package
RESOURCE_DIR = os.path.abspath(
@ -15,43 +18,114 @@ TEST_ZIP_REQ = 'file://{}#{}' \
.format(os.path.join(RESOURCE_DIR, 'pyhelloworld3.zip'), TEST_NEW_REQ)
class TestPackageUtil(unittest.TestCase):
@patch('homeassistant.util.package.subprocess.call')
@patch('homeassistant.util.package.check_package_exists')
class TestPackageUtilInstallPackage(unittest.TestCase):
"""Test for homeassistant.util.package module."""
def setUp(self):
"""Create local library for testing."""
self.tmp_dir = tempfile.TemporaryDirectory()
self.lib_dir = mount_local_lib_path(self.tmp_dir.name)
def tearDown(self):
"""Stop everything that was started."""
self.tmp_dir.cleanup()
def test_install_existing_package(self):
def test_install_existing_package(self, mock_exists, mock_subprocess):
"""Test an install attempt on an existing package."""
self.assertTrue(package.check_package_exists(
TEST_EXIST_REQ, self.lib_dir))
mock_exists.return_value = True
self.assertTrue(package.install_package(TEST_EXIST_REQ))
def test_install_package_zip(self):
"""Test an install attempt from a zip path."""
self.assertFalse(package.check_package_exists(
TEST_ZIP_REQ, self.lib_dir))
self.assertFalse(package.check_package_exists(
TEST_NEW_REQ, self.lib_dir))
self.assertEqual(mock_exists.call_count, 1)
self.assertEqual(mock_exists.call_args, call(TEST_EXIST_REQ, None))
self.assertTrue(package.install_package(
TEST_ZIP_REQ, True, self.lib_dir))
self.assertEqual(mock_subprocess.call_count, 0)
self.assertTrue(package.check_package_exists(
TEST_ZIP_REQ, self.lib_dir))
self.assertTrue(package.check_package_exists(
TEST_NEW_REQ, self.lib_dir))
@patch('homeassistant.util.package.sys')
def test_install(self, mock_sys, mock_exists, mock_subprocess):
"""Test an install attempt on a package that doesn't exist."""
mock_exists.return_value = False
mock_subprocess.return_value = 0
try:
import pyhelloworld3
except ImportError:
self.fail('Unable to import pyhelloworld3 after installing it.')
self.assertTrue(package.install_package(TEST_NEW_REQ, False))
self.assertEqual(pyhelloworld3.__version__, '1.0.0')
self.assertEqual(mock_exists.call_count, 1)
self.assertEqual(mock_subprocess.call_count, 1)
self.assertEqual(
mock_subprocess.call_args,
call([
mock_sys.executable, '-m', 'pip',
'install', '--quiet', TEST_NEW_REQ
])
)
@patch('homeassistant.util.package.sys')
def test_install_upgrade(self, mock_sys, mock_exists, mock_subprocess):
"""Test an upgrade attempt on a package."""
mock_exists.return_value = False
mock_subprocess.return_value = 0
self.assertTrue(package.install_package(TEST_NEW_REQ))
self.assertEqual(mock_exists.call_count, 1)
self.assertEqual(mock_subprocess.call_count, 1)
self.assertEqual(
mock_subprocess.call_args,
call([
mock_sys.executable, '-m', 'pip', 'install',
'--quiet', TEST_NEW_REQ, '--upgrade'
])
)
@patch('homeassistant.util.package.sys')
def test_install_target(self, mock_sys, mock_exists, mock_subprocess):
"""Test an install with a target."""
target = 'target_folder'
mock_exists.return_value = False
mock_subprocess.return_value = 0
self.assertTrue(
package.install_package(TEST_NEW_REQ, False, target=target)
)
self.assertEqual(mock_exists.call_count, 1)
self.assertEqual(mock_subprocess.call_count, 1)
self.assertEqual(
mock_subprocess.call_args,
call([
mock_sys.executable, '-m', 'pip', 'install', '--quiet',
TEST_NEW_REQ, '--target', os.path.abspath(target)
])
)
@patch('homeassistant.util.package._LOGGER')
@patch('homeassistant.util.package.sys')
def test_install_error(
self, mock_sys, mock_logger, mock_exists, mock_subprocess
):
"""Test an install with a target."""
mock_exists.return_value = False
mock_subprocess.side_effect = [subprocess.SubprocessError]
self.assertFalse(package.install_package(TEST_NEW_REQ))
self.assertEqual(mock_logger.exception.call_count, 1)
class TestPackageUtilCheckPackageExists(unittest.TestCase):
"""Test for homeassistant.util.package module."""
def test_check_package_global(self):
"""Test for a globally-installed package"""
installed_package = list(pkg_resources.working_set)[0].project_name
self.assertTrue(package.check_package_exists(installed_package, None))
def test_check_package_local(self):
"""Test for a locally-installed package"""
lib_dir = get_python_lib()
installed_package = list(pkg_resources.working_set)[0].project_name
self.assertTrue(
package.check_package_exists(installed_package, lib_dir)
)
def test_check_package_zip(self):
"""Test for an installed zip package"""
self.assertFalse(package.check_package_exists(TEST_ZIP_REQ, None))

216
tests/util/test_yaml.py
View file

@ -2,7 +2,6 @@
import io
import unittest
import os
import tempfile
from unittest.mock import patch
from homeassistant.exceptions import HomeAssistantError
@ -68,146 +67,116 @@ class TestYaml(unittest.TestCase):
def test_include_yaml(self):
"""Test include yaml."""
with tempfile.NamedTemporaryFile() as include_file:
include_file.write(b"value")
include_file.seek(0)
conf = "key: !include {}".format(include_file.name)
with patch_yaml_files({'test.yaml': 'value'}):
conf = 'key: !include test.yaml'
with io.StringIO(conf) as file:
doc = yaml.yaml.safe_load(file)
assert doc["key"] == "value"
def test_include_dir_list(self):
@patch('homeassistant.util.yaml.os.walk')
def test_include_dir_list(self, mock_walk):
"""Test include dir list yaml."""
with tempfile.TemporaryDirectory() as include_dir:
file_1 = tempfile.NamedTemporaryFile(dir=include_dir,
suffix=".yaml", delete=False)
file_1.write(b"one")
file_1.close()
file_2 = tempfile.NamedTemporaryFile(dir=include_dir,
suffix=".yaml", delete=False)
file_2.write(b"two")
file_2.close()
conf = "key: !include_dir_list {}".format(include_dir)
mock_walk.return_value = [['/tmp', [], ['one.yaml', 'two.yaml']]]
with patch_yaml_files({
'/tmp/one.yaml': 'one', '/tmp/two.yaml': 'two'
}):
conf = "key: !include_dir_list /tmp"
with io.StringIO(conf) as file:
doc = yaml.yaml.safe_load(file)
assert sorted(doc["key"]) == sorted(["one", "two"])
def test_include_dir_list_recursive(self):
@patch('homeassistant.util.yaml.os.walk')
def test_include_dir_list_recursive(self, mock_walk):
"""Test include dir recursive list yaml."""
with tempfile.TemporaryDirectory() as include_dir:
file_0 = tempfile.NamedTemporaryFile(dir=include_dir,
suffix=".yaml", delete=False)
file_0.write(b"zero")
file_0.close()
temp_dir = tempfile.TemporaryDirectory(dir=include_dir)
file_1 = tempfile.NamedTemporaryFile(dir=temp_dir.name,
suffix=".yaml", delete=False)
file_1.write(b"one")
file_1.close()
file_2 = tempfile.NamedTemporaryFile(dir=temp_dir.name,
suffix=".yaml", delete=False)
file_2.write(b"two")
file_2.close()
conf = "key: !include_dir_list {}".format(include_dir)
mock_walk.return_value = [
['/tmp', ['tmp2'], ['zero.yaml']],
['/tmp/tmp2', [], ['one.yaml', 'two.yaml']],
]
with patch_yaml_files({
'/tmp/zero.yaml': 'zero', '/tmp/tmp2/one.yaml': 'one',
'/tmp/tmp2/two.yaml': 'two'
}):
conf = "key: !include_dir_list /tmp"
with io.StringIO(conf) as file:
doc = yaml.yaml.safe_load(file)
assert sorted(doc["key"]) == sorted(["zero", "one", "two"])
def test_include_dir_named(self):
@patch('homeassistant.util.yaml.os.walk')
def test_include_dir_named(self, mock_walk):
"""Test include dir named yaml."""
with tempfile.TemporaryDirectory() as include_dir:
file_1 = tempfile.NamedTemporaryFile(dir=include_dir,
suffix=".yaml", delete=False)
file_1.write(b"one")
file_1.close()
file_2 = tempfile.NamedTemporaryFile(dir=include_dir,
suffix=".yaml", delete=False)
file_2.write(b"two")
file_2.close()
conf = "key: !include_dir_named {}".format(include_dir)
correct = {}
correct[os.path.splitext(os.path.basename(file_1.name))[0]] = "one"
correct[os.path.splitext(os.path.basename(file_2.name))[0]] = "two"
mock_walk.return_value = [['/tmp', [], ['first.yaml', 'second.yaml']]]
with patch_yaml_files({
'/tmp/first.yaml': 'one', '/tmp/second.yaml': 'two'
}):
conf = "key: !include_dir_named /tmp"
correct = {'first': 'one', 'second': 'two'}
with io.StringIO(conf) as file:
doc = yaml.yaml.safe_load(file)
assert doc["key"] == correct
def test_include_dir_named_recursive(self):
@patch('homeassistant.util.yaml.os.walk')
def test_include_dir_named_recursive(self, mock_walk):
"""Test include dir named yaml."""
with tempfile.TemporaryDirectory() as include_dir:
file_0 = tempfile.NamedTemporaryFile(dir=include_dir,
suffix=".yaml", delete=False)
file_0.write(b"zero")
file_0.close()
temp_dir = tempfile.TemporaryDirectory(dir=include_dir)
file_1 = tempfile.NamedTemporaryFile(dir=temp_dir.name,
suffix=".yaml", delete=False)
file_1.write(b"one")
file_1.close()
file_2 = tempfile.NamedTemporaryFile(dir=temp_dir.name,
suffix=".yaml", delete=False)
file_2.write(b"two")
file_2.close()
conf = "key: !include_dir_named {}".format(include_dir)
correct = {}
correct[os.path.splitext(
os.path.basename(file_0.name))[0]] = "zero"
correct[os.path.splitext(os.path.basename(file_1.name))[0]] = "one"
correct[os.path.splitext(os.path.basename(file_2.name))[0]] = "two"
mock_walk.return_value = [
['/tmp', ['tmp2'], ['first.yaml']],
['/tmp/tmp2', [], ['second.yaml', 'third.yaml']],
]
with patch_yaml_files({
'/tmp/first.yaml': 'one', '/tmp/tmp2/second.yaml': 'two',
'/tmp/tmp2/third.yaml': 'three'
}):
conf = "key: !include_dir_named /tmp"
correct = {'first': 'one', 'second': 'two', 'third': 'three'}
with io.StringIO(conf) as file:
doc = yaml.yaml.safe_load(file)
assert doc["key"] == correct
def test_include_dir_merge_list(self):
@patch('homeassistant.util.yaml.os.walk')
def test_include_dir_merge_list(self, mock_walk):
"""Test include dir merge list yaml."""
with tempfile.TemporaryDirectory() as include_dir:
file_1 = tempfile.NamedTemporaryFile(dir=include_dir,
suffix=".yaml", delete=False)
file_1.write(b"- one")
file_1.close()
file_2 = tempfile.NamedTemporaryFile(dir=include_dir,
suffix=".yaml", delete=False)
file_2.write(b"- two\n- three")
file_2.close()
conf = "key: !include_dir_merge_list {}".format(include_dir)
mock_walk.return_value = [['/tmp', [], ['first.yaml', 'second.yaml']]]
with patch_yaml_files({
'/tmp/first.yaml': '- one',
'/tmp/second.yaml': '- two\n- three'
}):
conf = "key: !include_dir_merge_list /tmp"
with io.StringIO(conf) as file:
doc = yaml.yaml.safe_load(file)
assert sorted(doc["key"]) == sorted(["one", "two", "three"])
def test_include_dir_merge_list_recursive(self):
@patch('homeassistant.util.yaml.os.walk')
def test_include_dir_merge_list_recursive(self, mock_walk):
"""Test include dir merge list yaml."""
with tempfile.TemporaryDirectory() as include_dir:
file_0 = tempfile.NamedTemporaryFile(dir=include_dir,
suffix=".yaml", delete=False)
file_0.write(b"- zero")
file_0.close()
temp_dir = tempfile.TemporaryDirectory(dir=include_dir)
file_1 = tempfile.NamedTemporaryFile(dir=temp_dir.name,
suffix=".yaml", delete=False)
file_1.write(b"- one")
file_1.close()
file_2 = tempfile.NamedTemporaryFile(dir=temp_dir.name,
suffix=".yaml", delete=False)
file_2.write(b"- two\n- three")
file_2.close()
conf = "key: !include_dir_merge_list {}".format(include_dir)
mock_walk.return_value = [
['/tmp', ['tmp2'], ['first.yaml']],
['/tmp/tmp2', [], ['second.yaml', 'third.yaml']],
]
with patch_yaml_files({
'/tmp/first.yaml': '- one', '/tmp/tmp2/second.yaml': '- two',
'/tmp/tmp2/third.yaml': '- three\n- four'
}):
conf = "key: !include_dir_merge_list /tmp"
with io.StringIO(conf) as file:
doc = yaml.yaml.safe_load(file)
assert sorted(doc["key"]) == sorted(["zero", "one", "two",
"three"])
assert sorted(doc["key"]) == sorted(["one", "two",
"three", "four"])
def test_include_dir_merge_named(self):
@patch('homeassistant.util.yaml.os.walk')
def test_include_dir_merge_named(self, mock_walk):
"""Test include dir merge named yaml."""
with tempfile.TemporaryDirectory() as include_dir:
file_1 = tempfile.NamedTemporaryFile(dir=include_dir,
suffix=".yaml", delete=False)
file_1.write(b"key1: one")
file_1.close()
file_2 = tempfile.NamedTemporaryFile(dir=include_dir,
suffix=".yaml", delete=False)
file_2.write(b"key2: two\nkey3: three")
file_2.close()
conf = "key: !include_dir_merge_named {}".format(include_dir)
mock_walk.return_value = [['/tmp', [], ['first.yaml', 'second.yaml']]]
with patch_yaml_files({
'/tmp/first.yaml': 'key1: one',
'/tmp/second.yaml': 'key2: two\nkey3: three'
}):
conf = "key: !include_dir_merge_named /tmp"
with io.StringIO(conf) as file:
doc = yaml.yaml.safe_load(file)
assert doc["key"] == {
@ -216,30 +185,27 @@ class TestYaml(unittest.TestCase):
"key3": "three"
}
def test_include_dir_merge_named_recursive(self):
@patch('homeassistant.util.yaml.os.walk')
def test_include_dir_merge_named_recursive(self, mock_walk):
"""Test include dir merge named yaml."""
with tempfile.TemporaryDirectory() as include_dir:
file_0 = tempfile.NamedTemporaryFile(dir=include_dir,
suffix=".yaml", delete=False)
file_0.write(b"key0: zero")
file_0.close()
temp_dir = tempfile.TemporaryDirectory(dir=include_dir)
file_1 = tempfile.NamedTemporaryFile(dir=temp_dir.name,
suffix=".yaml", delete=False)
file_1.write(b"key1: one")
file_1.close()
file_2 = tempfile.NamedTemporaryFile(dir=temp_dir.name,
suffix=".yaml", delete=False)
file_2.write(b"key2: two\nkey3: three")
file_2.close()
conf = "key: !include_dir_merge_named {}".format(include_dir)
mock_walk.return_value = [
['/tmp', ['tmp2'], ['first.yaml']],
['/tmp/tmp2', [], ['second.yaml', 'third.yaml']],
]
with patch_yaml_files({
'/tmp/first.yaml': 'key1: one',
'/tmp/tmp2/second.yaml': 'key2: two',
'/tmp/tmp2/third.yaml': 'key3: three\nkey4: four'
}):
conf = "key: !include_dir_merge_named /tmp"
with io.StringIO(conf) as file:
doc = yaml.yaml.safe_load(file)
assert doc["key"] == {
"key0": "zero",
"key1": "one",
"key2": "two",
"key3": "three"
"key3": "three",
"key4": "four"
}
FILES = {}