salt/tests/unit/utils/test_win_reg.py

# -*- 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.mock import patch, MagicMock
from tests.support.unit import TestCase, skipIf

# Import Salt Libs
import salt.utils.stringutils
import salt.utils.win_reg as win_reg
from salt.exceptions import CommandExecutionError
from salt.ext import six

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):
    '''
    Test cases for salt.utils.win_reg
    '''
    def test_broadcast_change_success(self):
        '''
        Tests the broadcast_change function
        '''
        with patch('win32gui.SendMessageTimeout', return_value=('', 0)):
            self.assertTrue(win_reg.broadcast_change())

    def test_broadcast_change_fail(self):
        '''
        Tests the broadcast_change function failure
        '''
        with patch('win32gui.SendMessageTimeout', return_value=('', 1)):
            self.assertFalse(win_reg.broadcast_change())

    def test_key_exists_existing(self):
        '''
        Tests the key_exists function using a well known registry key
        '''
        self.assertTrue(
            win_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(win_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,
                          win_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,
                              win_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(
            win_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(
            win_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,
                          win_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(
                win_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,
                win_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(
                win_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(
                win_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',
            win_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(win_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,
                          win_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,
                              win_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 = win_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(win_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,
                          win_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,
                              win_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 = win_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 = win_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(
            win_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(
            win_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,
                          win_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,
                win_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,
                win_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(
                win_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(
                win_reg.read_value(
                    hive='HKLM',
                    key=FAKE_KEY,
                    vname='empty_list',
                ),
                expected
            )
        finally:
            win_reg.delete_key_recursive(hive='HKLM', key=FAKE_KEY)

    @destructiveTest
    def test_set_value(self):
        '''
        Test the set_value function
        '''
        try:
            self.assertTrue(
                win_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(
                win_reg.read_value(
                    hive='HKLM',
                    key=FAKE_KEY,
                    vname='fake_name'),
                expected)
        finally:
            win_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(
                win_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(
                win_reg.read_value(
                    hive='HKLM',
                    key=FAKE_KEY),
                expected)
        finally:
            win_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(
                win_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(
                win_reg.read_value(
                    hive='HKLM',
                    key='\\'.join([FAKE_KEY, UNICODE_KEY]),
                    vname='fake_name'),
                expected)
        finally:
            win_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(
                win_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(
                win_reg.read_value(
                    hive='HKLM',
                    key=FAKE_KEY,
                    vname='fake_unicode'),
                expected)
        finally:
            win_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(
                win_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(
                win_reg.read_value(
                    hive='HKLM',
                    key=FAKE_KEY,
                    vname='dword_value'),
                expected)
        finally:
            win_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(
                win_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(
                win_reg.read_value(
                    hive='HKLM',
                    key=FAKE_KEY,
                    vname='qword_value'),
                expected)
        finally:
            win_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,
                          win_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(
                win_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(
                win_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(
                win_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(
                win_reg.set_value(
                    hive='HKLM',
                    key=FAKE_KEY,
                    vname='fake_name',
                    vdata='fake_data'))

    def test_cast_vdata_reg_binary(self):
        '''
        Test the cast_vdata function with REG_BINARY
        Should always return binary data
        '''
        vdata = salt.utils.stringutils.to_bytes('test data')
        result = win_reg.cast_vdata(vdata=vdata, vtype='REG_BINARY')
        self.assertTrue(isinstance(result, six.binary_type))

        vdata = salt.utils.stringutils.to_str('test data')
        result = win_reg.cast_vdata(vdata=vdata, vtype='REG_BINARY')
        self.assertTrue(isinstance(result, six.binary_type))

        vdata = salt.utils.stringutils.to_unicode('test data')
        result = win_reg.cast_vdata(vdata=vdata, vtype='REG_BINARY')
        self.assertTrue(isinstance(result, six.binary_type))

    def test_cast_vdata_reg_dword(self):
        '''
        Test the cast_vdata function with REG_DWORD
        Should always return integer
        '''
        vdata = 1
        expected = 1
        result = win_reg.cast_vdata(vdata=vdata, vtype='REG_DWORD')
        self.assertEqual(result, expected)

        vdata = '1'
        result = win_reg.cast_vdata(vdata=vdata, vtype='REG_DWORD')
        self.assertEqual(result, expected)

        vdata = '0000001'
        result = win_reg.cast_vdata(vdata=vdata, vtype='REG_DWORD')
        self.assertEqual(result, expected)

    def test_cast_vdata_reg_expand_sz(self):
        '''
        Test the cast_vdata function with REG_EXPAND_SZ
        Should always return unicode
        '''
        vdata = salt.utils.stringutils.to_str('test data')
        result = win_reg.cast_vdata(vdata=vdata, vtype='REG_EXPAND_SZ')
        self.assertTrue(isinstance(result, six.text_type))

        vdata = salt.utils.stringutils.to_bytes('test data')
        result = win_reg.cast_vdata(vdata=vdata, vtype='REG_EXPAND_SZ')
        self.assertTrue(isinstance(result, six.text_type))

    def test_cast_vdata_reg_multi_sz(self):
        '''
        Test the cast_vdata function with REG_MULTI_SZ
        Should always return a list of unicode strings
        '''
        vdata = [salt.utils.stringutils.to_str('test string'),
                 salt.utils.stringutils.to_bytes('test bytes')]
        result = win_reg.cast_vdata(vdata=vdata, vtype='REG_MULTI_SZ')
        self.assertTrue(isinstance(result, list))
        for item in result:
            self.assertTrue(isinstance(item, six.text_type))

    def test_cast_vdata_reg_qword(self):
        '''
        Test the cast_vdata function with REG_QWORD
        Should always return a long integer
        `int` is `long` is default on Py3
        '''
        vdata = 1
        result = win_reg.cast_vdata(vdata=vdata, vtype='REG_QWORD')
        if six.PY2:
            self.assertTrue(isinstance(result, long))  # pylint: disable=incompatible-py3-code,undefined-variable
        else:
            self.assertTrue(isinstance(result, int))

        vdata = '1'
        result = win_reg.cast_vdata(vdata=vdata, vtype='REG_QWORD')
        if six.PY2:
            self.assertTrue(isinstance(result, long))  # pylint: disable=incompatible-py3-code,undefined-variable
        else:
            self.assertTrue(isinstance(result, int))

    def test_cast_vdata_reg_sz(self):
        '''
        Test the cast_vdata function with REG_SZ
        Should always return unicode
        '''
        vdata = salt.utils.stringutils.to_str('test data')
        result = win_reg.cast_vdata(vdata=vdata, vtype='REG_SZ')
        self.assertTrue(isinstance(result, six.text_type))

        vdata = salt.utils.stringutils.to_bytes('test data')
        result = win_reg.cast_vdata(vdata=vdata, vtype='REG_SZ')
        self.assertTrue(isinstance(result, six.text_type))

    @destructiveTest
    def test_delete_value(self):
        '''
        Test the delete_value function
        '''
        try:
            self.assertTrue(
                win_reg.set_value(
                    hive='HKLM',
                    key=FAKE_KEY,
                    vname='fake_name',
                    vdata='fake_data'))
            self.assertTrue(
                win_reg.delete_value(
                    hive='HKLM',
                    key=FAKE_KEY,
                    vname='fake_name'))
        finally:
            win_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(
                win_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,
                          win_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,
                              win_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(
                win_reg.set_value(
                    hive='HKLM',
                    key=FAKE_KEY,
                    vname='fake_unicode',
                    vdata=UNICODE_VALUE))
            self.assertTrue(
                win_reg.delete_value(
                    hive='HKLM',
                    key=FAKE_KEY,
                    vname='fake_unicode'))
        finally:
            win_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(
                win_reg.set_value(
                    hive='HKLM',
                    key=FAKE_KEY,
                    vname=UNICODE_KEY,
                    vdata='junk data'))
            self.assertTrue(
                win_reg.delete_value(
                    hive='HKLM',
                    key=FAKE_KEY,
                    vname=UNICODE_KEY))
        finally:
            win_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(
                win_reg.set_value(
                    hive='HKLM',
                    key='\\'.join([FAKE_KEY, UNICODE_KEY]),
                    vname='fake_name',
                    vdata='junk data'))
            self.assertTrue(
                win_reg.delete_value(
                    hive='HKLM',
                    key='\\'.join([FAKE_KEY, UNICODE_KEY]),
                    vname='fake_name'))
        finally:
            win_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,
                          win_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(
            win_reg.key_exists(hive='HKLM', key=FAKE_KEY))
        self.assertFalse(
            win_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(
                win_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(
                win_reg.set_value(
                    hive='HKLM',
                    key=FAKE_KEY,
                    vname='fake_name',
                    vdata='fake_value'))
            expected = {
                'Deleted': ['\\'.join(['HKLM', FAKE_KEY])],
                'Failed': []}
            self.assertDictEqual(
                win_reg.delete_key_recursive(
                    hive='HKLM',
                    key=FAKE_KEY),
                expected)
        finally:
            win_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(
                win_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(
                    win_reg.delete_key_recursive(
                        hive='HKLM',
                        key=FAKE_KEY),
                    expected)
        finally:
            win_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(
                win_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(
                    win_reg.delete_key_recursive(
                        hive='HKLM',
                        key=FAKE_KEY),
                    expected)
        finally:
            win_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(
                win_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(
                win_reg.delete_key_recursive(
                    hive='HKLM',
                    key='\\'.join([FAKE_KEY, UNICODE_KEY])),
                expected)
        finally:
            win_reg.delete_key_recursive(hive='HKLM', key=FAKE_KEY)

    def test__to_unicode_int(self):
        '''
        Test the ``_to_unicode`` function when it receives an integer value.
        Should return a unicode value, which is unicode in PY2 and str in PY3.
        '''
        if six.PY3:
            self.assertTrue(isinstance(win_reg._to_unicode(1), str))
        else:
            self.assertTrue(isinstance(win_reg._to_unicode(1), unicode))  # pylint: disable=incompatible-py3-code,undefined-variable