saltstack/salt
1
0
Fork 0
mirror of https://github.com/saltstack/salt.git synced 2025-04-17 10:10:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Merge branch 'master' into pdbedit_55185

Browse source
This commit is contained in:
Jorge Schrauwen 2020-01-18 21:06:53 +01:00 • committed by GitHub
commit a5179434e7
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
10 changed files with 938 additions and 29 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
doc/conf.py
View file

@ -255,9 +255,9 @@ on_saltstack = 'SALT_ON_SALTSTACK' in os.environ
project = 'Salt'
repo_primary_branch = 'master' # This is the default branch on GitHub for the Salt project
version = salt.version.__version__
latest_release = '2019.2.3' # latest release
previous_release = '2018.3.5' # latest release from previous branch
previous_release_dir = '2018.3' # path on web server for previous branch
latest_release = os.environ.get('LATEST_RELEASE', 'latest_release') # latest release (2019.2.3)
previous_release = os.environ.get('PREVIOUS_RELEASE', 'previous_release') # latest release from previous branch (2018.3.5)
previous_release_dir = os.environ.get('PREVIOUS_RELEASE_DIR', 'previous_release_dir') # path on web server for previous branch (2018.3)
next_release = '' # next release
next_release_dir = '' # path on web server for next release branch
@ -268,7 +268,7 @@ if on_saltstack:
copyright = time.strftime("%Y")
# < --- START do not merge these settings to other branches START ---> #
build_type = repo_primary_branch # latest, previous, master, next
build_type = os.environ.get('BUILD_TYPE', repo_primary_branch) # latest, previous, master, next
# < --- END do not merge these settings to other branches END ---> #
# Set google custom search engine
@ -282,7 +282,11 @@ elif build_type == 'next':
search_cx = '011515552685726825874:ht0p8miksrm' # latest
elif build_type == 'previous':
release = previous_release
if release.startswith('2018.3'):
if release.startswith('3000'):
search_cx = '011515552685726825874:3skhaozjtyn' # 3000
elif release.startswith('2019.2'):
search_cx = '011515552685726825874:huvjhlpptnm' # 2019.2
elif release.startswith('2018.3'):
search_cx = '011515552685726825874:vadptdpvyyu' # 2018.3
elif release.startswith('2017.7'):
search_cx = '011515552685726825874:w-hxmnbcpou' # 2017.7

23
doc/topics/releases/2018.3.5.rst
View file

@ -1,16 +1,15 @@
========================================
In Progress: Salt 2018.3.5 Release Notes
========================================
===========================
Salt 2018.3.5 Release Notes
===========================
Version 2018.3.5 is an **unreleased** bugfix release for :ref:`2018.3.0 <release-2018-3-0>`.
This release is still in progress and has not been released yet.
Version 2018.3.5 is a CVE-fix release for :ref:`2018.3.0 <release-2018-3-0>`.
Master Configuration Changes
============================
Security Fix
============
To fix `#53411`_ a new configuration parameter `event_listen_queue_max_seconds` is provided.
When this is set to a value greater than 0 and `event_listen_queue` is not 0, if the oldest event
in the listen queue is older than `event_listen_queue_max_seconds`, the queue will be flushed to
returners regardless of how many events are in the queue.
**CVE-2019-17361**
.. _`#53411`: https://github.com/saltstack/salt/issues/53411
With the Salt NetAPI enabled in addition to having a SSH roster defined,
unauthenticated access is possible when specifying the client as SSH.
Additionally, when the raw_shell option is specified any arbitrary command
may be run on the Salt master when specifying SSH options.

15
doc/topics/releases/2019.2.3.rst Normal file
View file

@ -0,0 +1,15 @@
===========================
Salt 2019.2.3 Release Notes
===========================
Version 2019.2.3 is a CVE-fix release for :ref:`2019.2.0 <release-2019-2-0>`.
Security Fix
============
**CVE-2019-17361**
With the Salt NetAPI enabled in addition to having a SSH roster defined,
unauthenticated access is possible when specifying the client as SSH.
Additionally, when the raw_shell option is specified any arbitrary command
may be run on the Salt master when specifying SSH options.

2
salt/modules/freezer.py
View file

@ -242,7 +242,7 @@ def restore(name=None, clean=False, **kwargs):
clean
If True remove the frozen information YAML from the cache
.. version-added:: 3000
.. versionadded:: 3000
CLI Example:

43
salt/modules/reg.py
View file

@ -123,6 +123,37 @@ def key_exists(hive, key, use_32bit_registry=False):
use_32bit_registry=use_32bit_registry)
def value_exists(hive, key, vname, use_32bit_registry=False):
r'''
Check that the value/data pair is found in the registry.
.. versionadded:: 3000
Args:
hive (str): The hive to connect to
key (str): The key to check in
vname (str): The name of the value/data pair you're checking
use_32bit_registry (bool): Look in the 32bit portion of the registry
Returns:
bool: True if exists, otherwise False
CLI Example:
.. code-block:: bash
salt '*' reg.value_exists HKLM SOFTWARE\Microsoft\Windows\CurrentVersion CommonFilesDir
'''
return __utils__['reg.value_exists'](hive=hive,
key=key,
vname=vname,
use_32bit_registry=use_32bit_registry)
def broadcast_change():
'''
Refresh the windows environment.
@ -180,10 +211,14 @@ def list_keys(hive, key=None, use_32bit_registry=False):
use_32bit_registry=use_32bit_registry)
def list_values(hive, key=None, use_32bit_registry=False, include_default=True):
def list_values(hive, key=None, use_32bit_registry=False):
r'''
Enumerates the values in a registry key or hive.
.. note::
The ``(Default)`` value will only be returned if it is set, otherwise it
will not be returned in the list of values.
Args:
hive (str):
@ -203,9 +238,6 @@ def list_values(hive, key=None, use_32bit_registry=False, include_default=True):
Accesses the 32bit portion of the registry on 64 bit installations.
On 32bit machines this is ignored.
include_default (bool):
Toggle whether to include the '(Default)' value.
Returns:
list: A list of values under the hive or key.
@ -217,8 +249,7 @@ def list_values(hive, key=None, use_32bit_registry=False, include_default=True):
'''
return __utils__['reg.list_values'](hive=hive,
key=key,
use_32bit_registry=use_32bit_registry,
include_default=include_default)
use_32bit_registry=use_32bit_registry)
def read_value(hive, key, vname=None, use_32bit_registry=False):

4
salt/modules/win_snmp.py
View file

@ -320,7 +320,7 @@ def get_community_names():
_LOG.debug('Loading communities from Group Policy settings')
current_values = __salt__['reg.list_values'](
_HKEY, _COMMUNITIES_GPO_KEY, include_default=False)
_HKEY, _COMMUNITIES_GPO_KEY)
# GPO settings are different in that they do not designate permissions
# They are a numbered list of communities like so:
@ -348,7 +348,7 @@ def get_community_names():
_LOG.debug('Loading communities from SNMP settings')
current_values = __salt__['reg.list_values'](
_HKEY, _COMMUNITIES_KEY, include_default=False)
_HKEY, _COMMUNITIES_KEY)
# The communities are stored as the community name with a numeric
# permission value. Like this (4 = Read Only):

2
salt/utils/data.py
View file

@ -1044,7 +1044,7 @@ def filter_falsey(data, recurse_depth=None, ignore_types=()):
:return type(data)
.. version-added:: 3000
.. versionadded:: 3000
'''
filter_element = (
functools.partial(filter_falsey,

2
salt/utils/win_osinfo.py
View file

@ -85,7 +85,7 @@ def get_join_info():
Gets information about the domain/workgroup. This will tell you if the
system is joined to a domain or a workgroup
.. version-added:: 2018.3.4
.. versionadded:: 2018.3.4
Returns:
dict: A dictionary containing the domain/workgroup and it's status

2
salt/utils/win_reg.py
View file

@ -210,7 +210,7 @@ def value_exists(hive, key, vname, use_32bit_registry=False):
'''
Check that the value/data pair is found in the registry.
.. version-added:: 2018.3.4
.. versionadded:: 2018.3.4
Args:

860
tests/unit/modules/test_reg.py Normal file
View file

@ -0,0 +1,860 @@
# -*- coding: utf-8 -*-
# Import Python Libs
from __future__ import absolute_import, unicode_literals, print_function
# Import Salt Testing Libs
from tests.support.helpers import destructiveTest, generate_random_name
from tests.support.mixins import LoaderModuleMockMixin
from tests.support.mock import patch, MagicMock
from tests.support.unit import TestCase, skipIf
# Import Salt Libs
import salt.modules.reg as reg
import salt.utils.stringutils
import salt.utils.win_reg
from salt.exceptions import CommandExecutionError
try:
import win32api
HAS_WIN32 = True
except ImportError:
HAS_WIN32 = False
UNICODE_KEY = 'Unicode Key \N{TRADE MARK SIGN}'
UNICODE_VALUE = 'Unicode Value ' \
'\N{COPYRIGHT SIGN},\N{TRADE MARK SIGN},\N{REGISTERED SIGN}'
FAKE_KEY = '\\'.join(['SOFTWARE', generate_random_name('SaltTesting-')])
@skipIf(not HAS_WIN32, 'Tests require win32 libraries')
class WinFunctionsTestCase(TestCase, LoaderModuleMockMixin):
'''
Test cases for salt.modules.reg
'''
def setup_loader_modules(self):
return {
reg: {
'__utils__': {
'reg.delete_value': salt.utils.win_reg.delete_value,
'reg.delete_key_recursive': salt.utils.win_reg.delete_key_recursive,
'reg.key_exists': salt.utils.win_reg.key_exists,
'reg.list_keys': salt.utils.win_reg.list_keys,
'reg.list_values': salt.utils.win_reg.list_values,
'reg.read_value': salt.utils.win_reg.read_value,
'reg.set_value': salt.utils.win_reg.set_value,
'reg.value_exists': salt.utils.win_reg.value_exists,
}
}
}
def test_key_exists_existing(self):
'''
Tests the key_exists function using a well known registry key
'''
self.assertTrue(
reg.key_exists(hive='HKLM', key='SOFTWARE\\Microsoft'))
def test_key_exists_non_existing(self):
'''
Tests the key_exists function using a non existing registry key
'''
self.assertFalse(reg.key_exists(hive='HKLM', key=FAKE_KEY))
def test_key_exists_invalid_hive(self):
'''
Tests the key_exists function using an invalid hive
'''
self.assertRaises(CommandExecutionError,
reg.key_exists,
hive='BADHIVE',
key='SOFTWARE\\Microsoft')
def test_key_exists_unknown_key_error(self):
'''
Tests the key_exists function with an unknown key error
'''
mock_error = MagicMock(
side_effect=win32api.error(123, 'RegOpenKeyEx', 'Unknown error'))
with patch('salt.utils.win_reg.win32api.RegOpenKeyEx', mock_error):
self.assertRaises(win32api.error,
reg.key_exists,
hive='HKLM',
key='SOFTWARE\\Microsoft')
def test_value_exists_existing(self):
'''
Tests the value_exists function using a well known registry key
'''
self.assertTrue(
reg.value_exists(
hive='HKLM',
key='SOFTWARE\\Microsoft\\Windows\\CurrentVersion',
vname='CommonFilesDir'))
def test_value_exists_non_existing(self):
'''
Tests the value_exists function using a non existing registry key
'''
self.assertFalse(
reg.value_exists(
hive='HKLM',
key='SOFTWARE\\Microsoft\\Windows\\CurrentVersion',
vname='NonExistingValueName'))
def test_value_exists_invalid_hive(self):
'''
Tests the value_exists function using an invalid hive
'''
self.assertRaises(CommandExecutionError,
reg.value_exists,
hive='BADHIVE',
key='SOFTWARE\\Microsoft\\Windows\\CurrentVersion',
vname='CommonFilesDir')
def test_value_exists_key_not_exist(self):
'''
Tests the value_exists function when the key does not exist
'''
mock_error = MagicMock(
side_effect=win32api.error(2, 'RegOpenKeyEx', 'Unknown error'))
with patch('salt.utils.win_reg.win32api.RegOpenKeyEx', mock_error):
self.assertFalse(
reg.value_exists(
hive='HKLM',
key='SOFTWARE\\Microsoft\\Windows\\CurrentVersion',
vname='CommonFilesDir'))
def test_value_exists_unknown_key_error(self):
'''
Tests the value_exists function with an unknown error when opening the
key
'''
mock_error = MagicMock(
side_effect=win32api.error(123, 'RegOpenKeyEx', 'Unknown error'))
with patch('salt.utils.win_reg.win32api.RegOpenKeyEx', mock_error):
self.assertRaises(
win32api.error,
reg.value_exists,
hive='HKLM',
key='SOFTWARE\\Microsoft\\Windows\\CurrentVersion',
vname='CommonFilesDir')
def test_value_exists_empty_default_value(self):
'''
Tests the value_exists function when querying the default value
'''
mock_error = MagicMock(
side_effect=win32api.error(2, 'RegQueryValueEx', 'Empty Value'))
with patch('salt.utils.win_reg.win32api.RegQueryValueEx', mock_error):
self.assertTrue(
reg.value_exists(
hive='HKLM',
key='SOFTWARE\\Microsoft\\Windows\\CurrentVersion',
vname=None))
def test_value_exists_no_vname(self):
'''
Tests the value_exists function when the vname does not exist
'''
mock_error = MagicMock(
side_effect=win32api.error(123, 'RegQueryValueEx', 'Empty Value'))
with patch('salt.utils.win_reg.win32api.RegQueryValueEx', mock_error):
self.assertFalse(
reg.value_exists(
hive='HKLM',
key='SOFTWARE\\Microsoft\\Windows\\CurrentVersion',
vname='NonExistingValuePair'))
def test_list_keys_existing(self):
'''
Test the list_keys function using a well known registry key
'''
self.assertIn(
'Microsoft',
reg.list_keys(hive='HKLM', key='SOFTWARE'))
def test_list_keys_non_existing(self):
'''
Test the list_keys function using a non existing registry key
'''
expected = (False, 'Cannot find key: HKLM\\{0}'.format(FAKE_KEY))
self.assertEqual(reg.list_keys(hive='HKLM', key=FAKE_KEY), expected)
def test_list_keys_invalid_hive(self):
'''
Test the list_keys function when passing an invalid hive
'''
self.assertRaises(CommandExecutionError,
reg.list_keys,
hive='BADHIVE',
key='SOFTWARE\\Microsoft')
def test_list_keys_unknown_key_error(self):
'''
Tests the list_keys function with an unknown key error
'''
mock_error = MagicMock(
side_effect=win32api.error(123, 'RegOpenKeyEx', 'Unknown error'))
with patch('salt.utils.win_reg.win32api.RegOpenKeyEx', mock_error):
self.assertRaises(win32api.error,
reg.list_keys,
hive='HKLM',
key='SOFTWARE\\Microsoft')
def test_list_values_existing(self):
'''
Test the list_values function using a well known registry key
'''
values = reg.list_values(
hive='HKLM',
key='SOFTWARE\\Microsoft\\Windows\\CurrentVersion')
keys = []
for value in values:
keys.append(value['vname'])
self.assertIn('ProgramFilesDir', keys)
def test_list_values_non_existing(self):
'''
Test the list_values function using a non existing registry key
'''
expected = (False, 'Cannot find key: HKLM\\{0}'.format(FAKE_KEY))
self.assertEqual(reg.list_values(hive='HKLM', key=FAKE_KEY),
expected)
def test_list_values_invalid_hive(self):
'''
Test the list_values function when passing an invalid hive
'''
self.assertRaises(CommandExecutionError,
reg.list_values,
hive='BADHIVE',
key='SOFTWARE\\Microsoft')
def test_list_values_unknown_key_error(self):
'''
Tests the list_values function with an unknown key error
'''
mock_error = MagicMock(
side_effect=win32api.error(123, 'RegOpenKeyEx', 'Unknown error'))
with patch('salt.utils.win_reg.win32api.RegOpenKeyEx', mock_error):
self.assertRaises(win32api.error,
reg.list_values,
hive='HKLM',
key='SOFTWARE\\Microsoft')
def test_read_value_existing(self):
'''
Test the read_value function using a well known registry value
'''
ret = reg.read_value(
hive='HKLM',
key='SOFTWARE\\Microsoft\\Windows\\CurrentVersion',
vname='ProgramFilesPath')
self.assertEqual(ret['vdata'], '%ProgramFiles%')
def test_read_value_default(self):
'''
Test the read_value function reading the default value using a well
known registry key
'''
ret = reg.read_value(
hive='HKLM',
key='SOFTWARE\\Microsoft\\Windows\\CurrentVersion')
self.assertEqual(ret['vdata'], '(value not set)')
def test_read_value_non_existing(self):
'''
Test the read_value function using a non existing value pair
'''
expected = {
'comment': 'Cannot find fake_name in HKLM\\SOFTWARE\\Microsoft\\'
'Windows\\CurrentVersion',
'vdata': None,
'vname': 'fake_name',
'success': False,
'hive': 'HKLM',
'key': 'SOFTWARE\\Microsoft\\Windows\\CurrentVersion'}
self.assertDictEqual(
reg.read_value(
hive='HKLM',
key='SOFTWARE\\Microsoft\\Windows\\CurrentVersion',
vname='fake_name'),
expected)
def test_read_value_non_existing_key(self):
'''
Test the read_value function using a non existing registry key
'''
expected = {
'comment': 'Cannot find key: HKLM\\{0}'.format(FAKE_KEY),
'vdata': None,
'vname': 'fake_name',
'success': False,
'hive': 'HKLM',
'key': FAKE_KEY}
self.assertDictEqual(
reg.read_value(
hive='HKLM',
key=FAKE_KEY,
vname='fake_name'),
expected)
def test_read_value_invalid_hive(self):
'''
Test the read_value function when passing an invalid hive
'''
self.assertRaises(CommandExecutionError,
reg.read_value,
hive='BADHIVE',
key='SOFTWARE\\Microsoft',
vname='ProgramFilesPath')
def test_read_value_unknown_key_error(self):
'''
Tests the read_value function with an unknown key error
'''
mock_error = MagicMock(
side_effect=win32api.error(123, 'RegOpenKeyEx', 'Unknown error'))
with patch('salt.utils.win_reg.win32api.RegOpenKeyEx', mock_error):
self.assertRaises(
win32api.error,
reg.read_value,
hive='HKLM',
key='SOFTWARE\\Microsoft\\Windows\\CurrentVersion',
vname='ProgramFilesPath')
def test_read_value_unknown_value_error(self):
'''
Tests the read_value function with an unknown value error
'''
mock_error = MagicMock(
side_effect=win32api.error(123, 'RegQueryValueEx', 'Unknown error'))
with patch('salt.utils.win_reg.win32api.RegQueryValueEx', mock_error):
self.assertRaises(
win32api.error,
reg.read_value,
hive='HKLM',
key='SOFTWARE\\Microsoft\\Windows\\CurrentVersion',
vname='ProgramFilesPath')
@destructiveTest
def test_read_value_multi_sz_empty_list(self):
'''
An empty REG_MULTI_SZ value should return an empty list, not None
'''
try:
self.assertTrue(
reg.set_value(
hive='HKLM',
key=FAKE_KEY,
vname='empty_list',
vdata=[],
vtype='REG_MULTI_SZ'
)
)
expected = {
'hive': 'HKLM',
'key': FAKE_KEY,
'success': True,
'vdata': [],
'vname': 'empty_list',
'vtype': 'REG_MULTI_SZ'
}
self.assertEqual(
reg.read_value(
hive='HKLM',
key=FAKE_KEY,
vname='empty_list',
),
expected
)
finally:
reg.delete_key_recursive(hive='HKLM', key=FAKE_KEY)
@destructiveTest
def test_set_value(self):
'''
Test the set_value function
'''
try:
self.assertTrue(
reg.set_value(
hive='HKLM',
key=FAKE_KEY,
vname='fake_name',
vdata='fake_data'))
expected = {
'hive': 'HKLM',
'key': FAKE_KEY,
'success': True,
'vdata': 'fake_data',
'vname': 'fake_name',
'vtype': 'REG_SZ'}
self.assertEqual(
reg.read_value(
hive='HKLM',
key=FAKE_KEY,
vname='fake_name'),
expected)
finally:
reg.delete_key_recursive(hive='HKLM', key=FAKE_KEY)
@destructiveTest
def test_set_value_default(self):
'''
Test the set_value function on the default value
'''
try:
self.assertTrue(
reg.set_value(
hive='HKLM',
key=FAKE_KEY,
vdata='fake_default_data'))
expected = {
'hive': 'HKLM',
'key': FAKE_KEY,
'success': True,
'vdata': 'fake_default_data',
'vname': '(Default)',
'vtype': 'REG_SZ'}
self.assertEqual(
reg.read_value(
hive='HKLM',
key=FAKE_KEY),
expected)
finally:
reg.delete_key_recursive(hive='HKLM', key=FAKE_KEY)
@destructiveTest
def test_set_value_unicode_key(self):
'''
Test the set_value function on a unicode key
'''
try:
self.assertTrue(
reg.set_value(
hive='HKLM',
key='\\'.join([FAKE_KEY, UNICODE_KEY]),
vname='fake_name',
vdata='fake_value'))
expected = {
'hive': 'HKLM',
'key': '\\'.join([FAKE_KEY, UNICODE_KEY]),
'success': True,
'vdata': 'fake_value',
'vname': 'fake_name',
'vtype': 'REG_SZ'}
self.assertEqual(
reg.read_value(
hive='HKLM',
key='\\'.join([FAKE_KEY, UNICODE_KEY]),
vname='fake_name'),
expected)
finally:
reg.delete_key_recursive(hive='HKLM', key=FAKE_KEY)
@destructiveTest
def test_set_value_unicode_value(self):
'''
Test the set_value function on a unicode value
'''
try:
self.assertTrue(
reg.set_value(
hive='HKLM',
key=FAKE_KEY,
vname='fake_unicode',
vdata=UNICODE_VALUE))
expected = {
'hive': 'HKLM',
'key': FAKE_KEY,
'success': True,
'vdata': UNICODE_VALUE,
'vname': 'fake_unicode',
'vtype': 'REG_SZ'}
self.assertEqual(
reg.read_value(
hive='HKLM',
key=FAKE_KEY,
vname='fake_unicode'),
expected)
finally:
reg.delete_key_recursive(hive='HKLM', key=FAKE_KEY)
@destructiveTest
def test_set_value_reg_dword(self):
'''
Test the set_value function on a REG_DWORD value
'''
try:
self.assertTrue(
reg.set_value(
hive='HKLM',
key=FAKE_KEY,
vname='dword_value',
vdata=123,
vtype='REG_DWORD'))
expected = {
'hive': 'HKLM',
'key': FAKE_KEY,
'success': True,
'vdata': 123,
'vname': 'dword_value',
'vtype': 'REG_DWORD'}
self.assertEqual(
reg.read_value(
hive='HKLM',
key=FAKE_KEY,
vname='dword_value'),
expected)
finally:
reg.delete_key_recursive(hive='HKLM', key=FAKE_KEY)
@destructiveTest
def test_set_value_reg_qword(self):
'''
Test the set_value function on a REG_QWORD value
'''
try:
self.assertTrue(
reg.set_value(
hive='HKLM',
key=FAKE_KEY,
vname='qword_value',
vdata=123,
vtype='REG_QWORD'))
expected = {
'hive': 'HKLM',
'key': FAKE_KEY,
'success': True,
'vdata': 123,
'vname': 'qword_value',
'vtype': 'REG_QWORD'}
self.assertEqual(
reg.read_value(
hive='HKLM',
key=FAKE_KEY,
vname='qword_value'),
expected)
finally:
reg.delete_key_recursive(hive='HKLM', key=FAKE_KEY)
def test_set_value_invalid_hive(self):
'''
Test the set_value function when passing an invalid hive
'''
self.assertRaises(CommandExecutionError,
reg.set_value,
hive='BADHIVE',
key=FAKE_KEY,
vname='fake_name',
vdata='fake_data')
def test_set_value_open_create_failure(self):
'''
Test the set_value function when there is a problem opening/creating
the key
'''
mock_error = MagicMock(
side_effect=win32api.error(123, 'RegCreateKeyEx', 'Unknown error'))
with patch('salt.utils.win_reg.win32api.RegCreateKeyEx', mock_error):
self.assertFalse(
reg.set_value(
hive='HKLM',
key=FAKE_KEY,
vname='fake_name',
vdata='fake_data'))
def test_set_value_type_error(self):
'''
Test the set_value function when the wrong type of data is passed
'''
mock_error = MagicMock(
side_effect=TypeError('Mocked TypeError'))
with patch('salt.utils.win_reg.win32api.RegSetValueEx', mock_error):
self.assertFalse(
reg.set_value(
hive='HKLM',
key=FAKE_KEY,
vname='fake_name',
vdata='fake_data'))
def test_set_value_system_error(self):
'''
Test the set_value function when a SystemError occurs while setting the
value
'''
mock_error = MagicMock(
side_effect=SystemError('Mocked SystemError'))
with patch('salt.utils.win_reg.win32api.RegSetValueEx', mock_error):
self.assertFalse(
reg.set_value(
hive='HKLM',
key=FAKE_KEY,
vname='fake_name',
vdata='fake_data'))
def test_set_value_value_error(self):
'''
Test the set_value function when a ValueError occurs while setting the
value
'''
mock_error = MagicMock(
side_effect=ValueError('Mocked ValueError'))
with patch('salt.utils.win_reg.win32api.RegSetValueEx', mock_error):
self.assertFalse(
reg.set_value(
hive='HKLM',
key=FAKE_KEY,
vname='fake_name',
vdata='fake_data'))
@destructiveTest
def test_delete_value(self):
'''
Test the delete_value function
'''
try:
self.assertTrue(
reg.set_value(
hive='HKLM',
key=FAKE_KEY,
vname='fake_name',
vdata='fake_data'))
self.assertTrue(
reg.delete_value(
hive='HKLM',
key=FAKE_KEY,
vname='fake_name'))
finally:
reg.delete_key_recursive(hive='HKLM', key=FAKE_KEY)
def test_delete_value_non_existing(self):
'''
Test the delete_value function on non existing value
'''
mock_error = MagicMock(
side_effect=win32api.error(2, 'RegOpenKeyEx', 'Unknown error'))
with patch('salt.utils.win_reg.win32api.RegOpenKeyEx', mock_error):
self.assertIsNone(
reg.delete_value(
hive='HKLM',
key=FAKE_KEY,
vname='fake_name'))
def test_delete_value_invalid_hive(self):
'''
Test the delete_value function when passing an invalid hive
'''
self.assertRaises(CommandExecutionError,
reg.delete_value,
hive='BADHIVE',
key=FAKE_KEY,
vname='fake_name')
def test_delete_value_unknown_error(self):
'''
Test the delete_value function when there is a problem opening the key
'''
mock_error = MagicMock(
side_effect=win32api.error(123, 'RegOpenKeyEx', 'Unknown error'))
with patch('salt.utils.win_reg.win32api.RegOpenKeyEx', mock_error):
self.assertRaises(win32api.error,
reg.delete_value,
hive='HKLM',
key=FAKE_KEY,
vname='fake_name')
@destructiveTest
def test_delete_value_unicode(self):
'''
Test the delete_value function on a unicode value
'''
try:
self.assertTrue(
reg.set_value(
hive='HKLM',
key=FAKE_KEY,
vname='fake_unicode',
vdata=UNICODE_VALUE))
self.assertTrue(
reg.delete_value(
hive='HKLM',
key=FAKE_KEY,
vname='fake_unicode'))
finally:
reg.delete_key_recursive(hive='HKLM', key=FAKE_KEY)
@destructiveTest
def test_delete_value_unicode_vname(self):
'''
Test the delete_value function on a unicode vname
'''
try:
self.assertTrue(
reg.set_value(
hive='HKLM',
key=FAKE_KEY,
vname=UNICODE_KEY,
vdata='junk data'))
self.assertTrue(
reg.delete_value(
hive='HKLM',
key=FAKE_KEY,
vname=UNICODE_KEY))
finally:
reg.delete_key_recursive(hive='HKLM', key=FAKE_KEY)
@destructiveTest
def test_delete_value_unicode_key(self):
'''
Test the delete_value function on a unicode key
'''
try:
self.assertTrue(
reg.set_value(
hive='HKLM',
key='\\'.join([FAKE_KEY, UNICODE_KEY]),
vname='fake_name',
vdata='junk data'))
self.assertTrue(
reg.delete_value(
hive='HKLM',
key='\\'.join([FAKE_KEY, UNICODE_KEY]),
vname='fake_name'))
finally:
reg.delete_key_recursive(hive='HKLM', key=FAKE_KEY)
def test_delete_key_recursive_invalid_hive(self):
'''
Test the delete_key_recursive function when passing an invalid hive
'''
self.assertRaises(CommandExecutionError,
reg.delete_key_recursive,
hive='BADHIVE',
key=FAKE_KEY)
def test_delete_key_recursive_key_not_found(self):
'''
Test the delete_key_recursive function when the passed key to delete is
not found.
'''
self.assertFalse(
reg.key_exists(hive='HKLM', key=FAKE_KEY))
self.assertFalse(
reg.delete_key_recursive(hive='HKLM', key=FAKE_KEY))
def test_delete_key_recursive_too_close(self):
'''
Test the delete_key_recursive function when the passed key to delete is
too close to root, such as
'''
mock_true = MagicMock(return_value=True)
with patch('salt.utils.win_reg.key_exists', mock_true):
self.assertFalse(
reg.delete_key_recursive(hive='HKLM', key='FAKE_KEY'))
@destructiveTest
def test_delete_key_recursive(self):
'''
Test the delete_key_recursive function
'''
try:
self.assertTrue(
reg.set_value(
hive='HKLM',
key=FAKE_KEY,
vname='fake_name',
vdata='fake_value'))
expected = {
'Deleted': ['\\'.join(['HKLM', FAKE_KEY])],
'Failed': []}
self.assertDictEqual(
reg.delete_key_recursive(
hive='HKLM',
key=FAKE_KEY),
expected)
finally:
reg.delete_key_recursive(hive='HKLM', key=FAKE_KEY)
@destructiveTest
def test_delete_key_recursive_failed_to_open_key(self):
'''
Test the delete_key_recursive function on failure to open the key
'''
try:
self.assertTrue(
reg.set_value(
hive='HKLM',
key=FAKE_KEY,
vname='fake_name',
vdata='fake_value'))
expected = {
'Deleted': [],
'Failed': ['\\'.join(['HKLM', FAKE_KEY]) +
' Failed to connect to key']}
mock_true = MagicMock(return_value=True)
mock_error = MagicMock(
side_effect=[
1,
win32api.error(3, 'RegOpenKeyEx',
'Failed to connect to key')
])
with patch('salt.utils.win_reg.key_exists', mock_true), \
patch('salt.utils.win_reg.win32api.RegOpenKeyEx', mock_error):
self.assertDictEqual(
reg.delete_key_recursive(
hive='HKLM',
key=FAKE_KEY),
expected)
finally:
reg.delete_key_recursive(hive='HKLM', key=FAKE_KEY)
@destructiveTest
def test_delete_key_recursive_failed_to_delete(self):
'''
Test the delete_key_recursive function on failure to delete a key
'''
try:
self.assertTrue(
reg.set_value(
hive='HKLM',
key=FAKE_KEY,
vname='fake_name',
vdata='fake_value'))
expected = {
'Deleted': [],
'Failed': ['\\'.join(['HKLM', FAKE_KEY]) + ' Unknown error']}
mock_error = MagicMock(side_effect=WindowsError('Unknown error')) # pylint: disable=undefined-variable
with patch('salt.utils.win_reg.win32api.RegDeleteKey', mock_error):
self.assertDictEqual(
reg.delete_key_recursive(
hive='HKLM',
key=FAKE_KEY),
expected)
finally:
reg.delete_key_recursive(hive='HKLM', key=FAKE_KEY)
@destructiveTest
def test_delete_key_recursive_unicode(self):
'''
Test the delete_key_recursive function on value within a unicode key
'''
try:
self.assertTrue(
reg.set_value(
hive='HKLM',
key='\\'.join([FAKE_KEY, UNICODE_KEY]),
vname='fake_name',
vdata='fake_value'))
expected = {
'Deleted': ['\\'.join(['HKLM', FAKE_KEY, UNICODE_KEY])],
'Failed': []}
self.assertDictEqual(
reg.delete_key_recursive(
hive='HKLM',
key='\\'.join([FAKE_KEY, UNICODE_KEY])),
expected)
finally:
reg.delete_key_recursive(hive='HKLM', key=FAKE_KEY)