mirror of
https://github.com/valitydev/salt.git
synced 2024-11-07 08:58:59 +00:00
303 lines
11 KiB
Python
303 lines
11 KiB
Python
# -*- coding: utf-8 -*-
|
|
'''
|
|
:synopsis: Unit Tests for Windows Registry Module 'module.reg'
|
|
:platform: Windows
|
|
:maturity: develop
|
|
:codeauthor: Damon Atkins <https://github.com/damon-atkins>
|
|
versionadded:: 2016.11.0
|
|
'''
|
|
# Import Python future libs
|
|
from __future__ import absolute_import
|
|
from __future__ import unicode_literals
|
|
# Import Python Libs
|
|
import sys
|
|
import time
|
|
# Import Salt Testing Libs
|
|
from tests.support.unit import TestCase, skipIf
|
|
from tests.support.helpers import destructiveTest
|
|
# Import Salt Libs
|
|
import salt.modules.reg as win_mod_reg
|
|
from salt.ext import six
|
|
try:
|
|
from salt.ext.six.moves import winreg as _winreg # pylint: disable=import-error,no-name-in-module
|
|
NO_WINDOWS_MODULES = False
|
|
except ImportError:
|
|
NO_WINDOWS_MODULES = True
|
|
|
|
PY2 = sys.version_info[0] == 2
|
|
# The following used to make sure we are not
|
|
# testing already existing data
|
|
# Note strftime retunrns a str, so we need to make it unicode
|
|
TIMEINT = int(time.time())
|
|
|
|
if PY2:
|
|
TIME_INT_UNICODE = six.text_type(TIMEINT)
|
|
TIMESTR = time.strftime('%X %x %Z').decode('utf-8')
|
|
else:
|
|
TIMESTR = time.strftime('%X %x %Z')
|
|
TIME_INT_UNICODE = str(TIMEINT) # pylint: disable=R0204
|
|
|
|
|
|
# we do not need to prefix this with u, as we are
|
|
# using from __future__ import unicode_literals
|
|
UNICODETEST_WITH_SIGNS = 'Testing Unicode \N{COPYRIGHT SIGN},\N{TRADE MARK SIGN},\N{REGISTERED SIGN} '+TIMESTR
|
|
UNICODETEST_WITHOUT_SIGNS = 'Testing Unicode'+TIMESTR
|
|
UNICODE_TEST_KEY = 'UnicodeKey \N{TRADE MARK SIGN} '+TIME_INT_UNICODE
|
|
UNICODE_TEST_KEY_DEL = 'Delete Me \N{TRADE MARK SIGN} '+TIME_INT_UNICODE
|
|
|
|
|
|
@skipIf(NO_WINDOWS_MODULES, 'requires Windows OS to test Windows registry')
|
|
class RegWinTestCase(TestCase):
|
|
'''
|
|
Test cases for salt.modules.reg
|
|
'''
|
|
|
|
@skipIf(not sys.platform.startswith("win"), "requires Windows OS")
|
|
def test_read_reg_plain(self):
|
|
'''
|
|
Test - Read a registry value from a subkey using Pythen 2 Strings or
|
|
Pythen 3 Bytes
|
|
'''
|
|
if not PY2:
|
|
self.skipTest('Invalid for Python Version 2')
|
|
|
|
subkey = b'Software\\Microsoft\\Windows NT\\CurrentVersion'
|
|
vname = b'PathName'
|
|
handle = _winreg.OpenKey(
|
|
_winreg.HKEY_LOCAL_MACHINE,
|
|
subkey,
|
|
0,
|
|
_winreg.KEY_ALL_ACCESS
|
|
)
|
|
(current_vdata, dummy_current_vtype) = _winreg.QueryValueEx(handle, vname)
|
|
_winreg.CloseKey(handle)
|
|
|
|
test_vdata = win_mod_reg.read_value(b'HKEY_LOCAL_MACHINE', subkey, vname)[b'vdata']
|
|
self.assertEqual(
|
|
test_vdata, current_vdata)
|
|
|
|
@skipIf(not sys.platform.startswith("win"), "requires Windows OS")
|
|
def test_read_reg_unicode(self):
|
|
'''
|
|
Test - Read a registry value from a subkey using Pythen 2 Unicode
|
|
or Pythen 3 Str i.e. Unicode
|
|
'''
|
|
subkey = 'Software\\Microsoft\\Windows NT\\CurrentVersion'
|
|
vname = 'PathName'
|
|
handle = _winreg.OpenKey(
|
|
_winreg.HKEY_LOCAL_MACHINE,
|
|
subkey,
|
|
0,
|
|
_winreg.KEY_ALL_ACCESS
|
|
)
|
|
(current_vdata, dummy_current_vtype) = _winreg.QueryValueEx(handle, vname)
|
|
_winreg.CloseKey(handle)
|
|
|
|
test_vdata = win_mod_reg.read_value(
|
|
'HKEY_LOCAL_MACHINE',
|
|
subkey,
|
|
vname)['vdata']
|
|
self.assertEqual(test_vdata, current_vdata)
|
|
|
|
@skipIf(not sys.platform.startswith("win"), "requires Windows OS")
|
|
def test_list_keys_fail(self):
|
|
'''
|
|
Test - Read list the keys under a subkey which does not exist.
|
|
'''
|
|
subkey = 'ThisIsJunkItDoesNotExistIhope'
|
|
test_list = win_mod_reg.list_keys('HKEY_LOCAL_MACHINE', subkey)
|
|
# returns a tuple with first item false, and second item a reason
|
|
test = isinstance(test_list, tuple) and (not test_list[0])
|
|
self.assertTrue(test)
|
|
|
|
@skipIf(not sys.platform.startswith("win"), "requires Windows OS")
|
|
def test_list_keys(self):
|
|
'''
|
|
Test - Read list the keys under a subkey
|
|
'''
|
|
subkey = 'Software\\Microsoft\\Windows NT\\CurrentVersion'
|
|
test_list = win_mod_reg.list_keys('HKEY_LOCAL_MACHINE', subkey)
|
|
test = len(test_list) > 5 # Their should be a lot more than 5 items
|
|
self.assertTrue(test)
|
|
|
|
@skipIf(not sys.platform.startswith("win"), "requires Windows OS")
|
|
def test_list_values_fail(self):
|
|
'''
|
|
Test - List the values under a subkey which does not exist.
|
|
'''
|
|
subkey = 'ThisIsJunkItDoesNotExistIhope'
|
|
test_list = win_mod_reg.list_values('HKEY_LOCAL_MACHINE', subkey)
|
|
# returns a tuple with first item false, and second item a reason
|
|
test = isinstance(test_list, tuple) and (not test_list[0])
|
|
self.assertTrue(test)
|
|
|
|
@skipIf(not sys.platform.startswith("win"), "requires Windows OS")
|
|
def test_list_values(self):
|
|
'''
|
|
Test - List the values under a subkey.
|
|
'''
|
|
subkey = r'Software\Microsoft\Windows NT\CurrentVersion'
|
|
test_list = win_mod_reg.list_values('HKEY_LOCAL_MACHINE', subkey)
|
|
test = len(test_list) > 5 # There should be a lot more than 5 items
|
|
self.assertTrue(test)
|
|
|
|
# Not considering this destructive as its writing to a private space
|
|
@skipIf(not sys.platform.startswith("win"), "requires Windows OS")
|
|
def test_set_value_unicode(self):
|
|
'''
|
|
Test - set a registry plain text subkey name to a unicode string value
|
|
'''
|
|
vname = 'TestUniccodeString'
|
|
subkey = 'Software\\SaltStackTest'
|
|
test1_success = False
|
|
test2_success = False
|
|
test1_success = win_mod_reg.set_value(
|
|
'HKEY_LOCAL_MACHINE',
|
|
subkey,
|
|
vname,
|
|
UNICODETEST_WITH_SIGNS
|
|
)
|
|
# Now use _winreg direct to see if it worked as expected
|
|
if test1_success:
|
|
handle = _winreg.OpenKey(
|
|
_winreg.HKEY_LOCAL_MACHINE,
|
|
subkey,
|
|
0,
|
|
_winreg.KEY_ALL_ACCESS
|
|
)
|
|
(current_vdata, dummy_current_vtype) = _winreg.QueryValueEx(handle, vname)
|
|
_winreg.CloseKey(handle)
|
|
test2_success = (current_vdata == UNICODETEST_WITH_SIGNS)
|
|
self.assertTrue(test1_success and test2_success)
|
|
|
|
@skipIf(not sys.platform.startswith("win"), "requires Windows OS")
|
|
def test_set_value_unicode_key(self):
|
|
'''
|
|
Test - set a registry Unicode subkey name with unicode characters within
|
|
to a integer
|
|
'''
|
|
test_success = win_mod_reg.set_value(
|
|
'HKEY_LOCAL_MACHINE',
|
|
'Software\\SaltStackTest',
|
|
UNICODE_TEST_KEY,
|
|
TIMEINT,
|
|
'REG_DWORD'
|
|
)
|
|
self.assertTrue(test_success)
|
|
|
|
@skipIf(not sys.platform.startswith("win"), "requires Windows OS")
|
|
def test_del_value(self):
|
|
'''
|
|
Test - Create Directly and Delete with salt a registry value
|
|
'''
|
|
subkey = 'Software\\SaltStackTest'
|
|
vname = UNICODE_TEST_KEY_DEL
|
|
vdata = 'I will be deleted'
|
|
if PY2:
|
|
handle = _winreg.CreateKeyEx(
|
|
_winreg.HKEY_LOCAL_MACHINE,
|
|
subkey.encode('mbcs'),
|
|
0,
|
|
_winreg.KEY_ALL_ACCESS
|
|
)
|
|
_winreg.SetValueEx(
|
|
handle,
|
|
vname.encode('mbcs'),
|
|
0,
|
|
_winreg.REG_SZ,
|
|
vdata.encode('mbcs')
|
|
)
|
|
else:
|
|
handle = _winreg.CreateKeyEx(
|
|
_winreg.HKEY_LOCAL_MACHINE,
|
|
subkey,
|
|
0,
|
|
_winreg.KEY_ALL_ACCESS
|
|
)
|
|
_winreg.SetValueEx(handle, vname, 0, _winreg.REG_SZ, vdata)
|
|
_winreg.CloseKey(handle)
|
|
# time.sleep(15) # delays for 15 seconds
|
|
test_success = win_mod_reg.delete_value(
|
|
'HKEY_LOCAL_MACHINE',
|
|
subkey,
|
|
vname
|
|
)
|
|
self.assertTrue(test_success)
|
|
|
|
@skipIf(not sys.platform.startswith("win"), "requires Windows OS")
|
|
def test_del_key_recursive_user(self):
|
|
'''
|
|
Test - Create directly key/value pair and Delete recusivly with salt
|
|
'''
|
|
subkey = 'Software\\SaltStackTest'
|
|
vname = UNICODE_TEST_KEY_DEL
|
|
vdata = 'I will be deleted recursive'
|
|
if PY2:
|
|
handle = _winreg.CreateKeyEx(
|
|
_winreg.HKEY_CURRENT_USER,
|
|
subkey.encode('mbcs'),
|
|
0,
|
|
_winreg.KEY_ALL_ACCESS
|
|
)
|
|
_winreg.SetValueEx(
|
|
handle,
|
|
vname.encode('mbcs'),
|
|
0,
|
|
_winreg.REG_SZ,
|
|
vdata.encode('mbcs')
|
|
)
|
|
else:
|
|
handle = _winreg.CreateKeyEx(
|
|
_winreg.HKEY_CURRENT_USER,
|
|
subkey,
|
|
0,
|
|
_winreg.KEY_ALL_ACCESS
|
|
)
|
|
_winreg.SetValueEx(handle, vname, 0, _winreg.REG_SZ, vdata)
|
|
_winreg.CloseKey(handle)
|
|
# time.sleep(15) # delays for 15 seconds so you can run regedit & watch it happen
|
|
test_success = win_mod_reg.delete_key_recursive('HKEY_CURRENT_USER', subkey)
|
|
self.assertTrue(test_success)
|
|
|
|
@skipIf(not sys.platform.startswith("win"), "requires Windows OS")
|
|
@destructiveTest
|
|
def test_del_key_recursive_machine(self):
|
|
'''
|
|
This is a DESTRUCTIVE TEST it creates a new registry entry.
|
|
And then destroys the registry entry recusively , however it is completed in its own space
|
|
within the registry. We mark this as destructiveTest as it has the potential
|
|
to detroy a machine if salt reg code has a large error in it.
|
|
'''
|
|
subkey = 'Software\\SaltStackTest'
|
|
vname = UNICODE_TEST_KEY_DEL
|
|
vdata = 'I will be deleted recursive'
|
|
if PY2:
|
|
handle = _winreg.CreateKeyEx(
|
|
_winreg.HKEY_LOCAL_MACHINE,
|
|
subkey.encode('mbcs'),
|
|
0,
|
|
_winreg.KEY_ALL_ACCESS
|
|
)
|
|
_winreg.SetValueEx(
|
|
handle,
|
|
vname.encode('mbcs'),
|
|
0,
|
|
_winreg.REG_SZ,
|
|
vdata.encode('mbcs')
|
|
)
|
|
else:
|
|
handle = _winreg.CreateKeyEx(
|
|
_winreg.HKEY_LOCAL_MACHINE,
|
|
subkey,
|
|
0,
|
|
_winreg.KEY_ALL_ACCESS
|
|
)
|
|
_winreg.SetValueEx(handle, vname, 0, _winreg.REG_SZ, vdata)
|
|
_winreg.CloseKey(handle)
|
|
# time.sleep(15) # delays for 15 seconds so you can run regedit and watch it happen
|
|
test_success = win_mod_reg.delete_key_recursive('HKEY_LOCAL_MACHINE', subkey)
|
|
self.assertTrue(test_success)
|
|
|
|
# pylint: disable=W0511
|
|
# TODO: Test other hives, other than HKEY_LOCAL_MACHINE and HKEY_CURRENT_USER
|