def test_present_perms(reg_vars, clean): reg.present( name=reg_vars.name, vname=reg_vars.vname, vdata=reg_vars.vdata, win_perms={"Backup Operators": { "perms": "full_control" }}, win_deny_perms={"Guest": { "perms": "full_control" }}, ) permissions = win_dacl.get_permissions(obj_name=reg_vars.name, obj_type="registry") expected = { "deny": { "permissions": "Full Control", "applies to": "This key and subkeys" } } assert permissions["Not Inherited"].get("Guest") == expected expected = { "grant": { "permissions": "Full Control", "applies to": "This key and subkeys" } } assert permissions["Not Inherited"].get("Backup Operators") == expected
def test_present_perms_reset_no_inherit(reg_vars, clean): reg.present( name=reg_vars.name, vname=reg_vars.vname, vdata=reg_vars.vdata, win_perms={"Everyone": { "perms": "full_control" }}, win_deny_perms={"Guest": { "perms": "full_control" }}, win_perms_reset=True, win_inheritance=False, ) permissions = win_dacl.get_permissions(obj_name=reg_vars.name, obj_type="registry") expected = { "Guest": { "deny": { "permissions": "Full Control", "applies to": "This key and subkeys", } }, "Everyone": { "grant": { "permissions": "Full Control", "applies to": "This key and subkeys", } }, } assert permissions["Not Inherited"] == expected assert not win_dacl.get_inheritance(obj_name=reg_vars.name, obj_type="registry") assert permissions["Inherited"] == {}
def test_present(self): ''' Test to set a registry entry. ''' name = 'HKEY_CURRENT_USER\\SOFTWARE\\Salt\\version' value = '0.15.3' ret = {'name': name, 'changes': {}, 'result': True, 'comment': '{0} is already configured'.format(name)} mock = MagicMock(side_effect=[value, 'a', 'a']) mock_t = MagicMock(return_value=True) with patch.dict(reg.__salt__, {'reg.read_key': mock, 'reg.set_key': mock_t}): self.assertDictEqual(reg.present(name, value), ret) with patch.dict(reg.__opts__, {'test': True}): ret.update({'comment': '', 'result': None, 'changes': {'reg': 'configured to 0.15.3'}}) self.assertDictEqual(reg.present(name, value), ret) with patch.dict(reg.__opts__, {'test': False}): ret.update({'result': True}) self.assertDictEqual(reg.present(name, value), ret)
def test_present(self): ''' Test to set a registry entry. ''' name = 'HKEY_CURRENT_USER\\SOFTWARE\\Salt\\version' value = '0.15.3' ret = { 'name': name, 'changes': {}, 'result': True, 'comment': '{0} is already configured'.format(name) } mock = MagicMock(side_effect=[value, 'a', 'a']) mock_t = MagicMock(return_value=True) with patch.dict(reg.__salt__, { 'reg.read_key': mock, 'reg.set_key': mock_t }): self.assertDictEqual(reg.present(name, value), ret) with patch.dict(reg.__opts__, {'test': True}): ret.update({ 'comment': '', 'result': None, 'changes': { 'reg': 'configured to 0.15.3' } }) self.assertDictEqual(reg.present(name, value), ret) with patch.dict(reg.__opts__, {'test': False}): ret.update({'result': True}) self.assertDictEqual(reg.present(name, value), ret)
def test_present_perms_no_inherit(reg_vars, clean): reg.present( name=reg_vars.name, vname=reg_vars.vname, vdata=reg_vars.vdata, win_inheritance=False, ) assert not win_dacl.get_inheritance(obj_name=reg_vars.name, obj_type="registry") permissions = win_dacl.get_permissions(obj_name=reg_vars.name, obj_type="registry") assert permissions["Inherited"] == {}
def test_present_set_owner(reg_vars, clean): """ Test reg.present """ reg.present( name=reg_vars.name, vname=reg_vars.vname, vdata=reg_vars.vdata, win_owner=reg_vars.current_user, ) assert (win_dacl.get_owner(obj_name=reg_vars.name, obj_type="registry") == reg_vars.current_user)
def test_present_string_dword(reg_vars, clean): """ Test to set a registry entry. """ vname = "dword_data" vdata = "00000001" vtype = "REG_DWORD" expected_vdata = 1 expected = { "comment": "Added {} to {}".format(vname, reg_vars.name), "changes": { "reg": { "Added": { "Inheritance": True, "Perms": { "Deny": None, "Grant": None }, "Value": expected_vdata, "Key": reg_vars.name, "Owner": None, "Entry": vname, } } }, "name": reg_vars.name, "result": True, } assert (reg.present(name=reg_vars.name, vname=vname, vdata=vdata, vtype=vtype) == expected)
def test_present_string_dword(self): """ Test to set a registry entry. """ vname = "dword_data" vdata = "00000001" vtype = "REG_DWORD" expected_vdata = 1 expected = { "comment": "Added {0} to {1}".format(vname, self.name), "pchanges": {}, "changes": { "reg": { "Added": { "Inheritance": True, "Perms": { "Deny": None, "Grant": None }, "Value": expected_vdata, "Key": self.name, "Owner": None, "Entry": vname, } } }, "name": self.name, "result": True, } ret = reg.present(self.name, vname=vname, vdata=vdata, vtype=vtype) self.assertDictEqual(ret, expected)
def test_present_string_dword(self): ''' Test to set a registry entry. ''' vname = 'dword_data' vdata = '00000001' vtype = 'REG_DWORD' expected_vdata = 1 expected = { 'comment': 'Added {0} to {1}'.format(vname, self.name), 'pchanges': {}, 'changes': { 'reg': { 'Added': { 'Inheritance': True, 'Perms': { 'Deny': None, 'Grant': None }, 'Value': expected_vdata, 'Key': self.name, 'Owner': None, 'Entry': vname } } }, 'name': self.name, 'result': True } ret = reg.present(self.name, vname=vname, vdata=vdata, vtype=vtype) self.assertDictEqual(ret, expected)
def test_present(reg_vars): """ Test reg.present """ expected = { "comment": "Added {} to {}".format(reg_vars.vname, reg_vars.name), "changes": { "reg": { "Added": { "Inheritance": True, "Perms": { "Deny": None, "Grant": None }, "Value": reg_vars.vdata, "Key": reg_vars.name, "Owner": None, "Entry": reg_vars.vname, } } }, "name": reg_vars.name, "result": True, } assert (reg.present(name=reg_vars.name, vname=reg_vars.vname, vdata=reg_vars.vdata) == expected) permissions = win_dacl.get_permissions(obj_name=reg_vars.name, obj_type="registry") assert permissions["Not Inherited"] == {}
def test_present_test_true(reg_vars, clean): expected = { "comment": "", "changes": { "reg": { "Will add": { "Inheritance": True, "Perms": { "Deny": None, "Grant": None }, "Value": reg_vars.vdata, "Key": reg_vars.name, "Owner": None, "Entry": "version", } } }, "name": reg_vars.name, "result": None, } with patch.dict(reg.__opts__, {"test": True}): ret = reg.present(reg_vars.name, vname=reg_vars.vname, vdata=reg_vars.vdata) assert ret == expected
def test_present_test_true(self): expected = { 'comment': '', 'pchanges': {}, 'changes': { 'reg': { 'Will add': { 'Inheritance': True, 'Perms': { 'Deny': None, 'Grant': None }, 'Value': self.vdata, 'Key': self.name, 'Owner': None, 'Entry': 'version' } } }, 'name': self.name, 'result': None } with patch.dict(reg.__opts__, {'test': True}): ret = reg.present(self.name, vname=self.vname, vdata=self.vdata) self.assertDictEqual(ret, expected)
def test_present(self): ''' Test to set a registry entry. ''' expected = { 'comment': 'Added {0} to {1}'.format(self.vname, self.name), 'pchanges': {}, 'changes': { 'reg': { 'Added': { 'Inheritance': True, 'Perms': { 'Deny': None, 'Grant': None }, 'Value': self.vdata, 'Key': self.name, 'Owner': None, 'Entry': self.vname } } }, 'name': self.name, 'result': True } ret = reg.present(self.name, vname=self.vname, vdata=self.vdata) self.assertDictEqual(ret, expected)
def test_present_test_true(self): expected = { "comment": "", "pchanges": {}, "changes": { "reg": { "Will add": { "Inheritance": True, "Perms": { "Deny": None, "Grant": None }, "Value": self.vdata, "Key": self.name, "Owner": None, "Entry": "version", } } }, "name": self.name, "result": None, } with patch.dict(reg.__opts__, {"test": True}): ret = reg.present(self.name, vname=self.vname, vdata=self.vdata) self.assertDictEqual(ret, expected)
def test_present(self): """ Test to set a registry entry. """ expected = { "comment": "Added {0} to {1}".format(self.vname, self.name), "pchanges": {}, "changes": { "reg": { "Added": { "Inheritance": True, "Perms": { "Deny": None, "Grant": None }, "Value": self.vdata, "Key": self.name, "Owner": None, "Entry": self.vname, } } }, "name": self.name, "result": True, } ret = reg.present(self.name, vname=self.vname, vdata=self.vdata) self.assertDictEqual(ret, expected)
def test_present_string_dword_existing(self): """ Test to set a registry entry. """ vname = "dword_data" vdata = "0000001" vtype = "REG_DWORD" # Set it first reg.present(self.name, vname=vname, vdata=vdata, vtype=vtype) expected = { "comment": "{} in {} is already present".format(vname, self.name), "changes": {}, "name": self.name, "result": True, } ret = reg.present(self.name, vname=vname, vdata=vdata, vtype=vtype) self.assertDictEqual(ret, expected)
def test_present_string_dword_existing(self): ''' Test to set a registry entry. ''' vname = 'dword_data' vdata = '0000001' vtype = 'REG_DWORD' # Set it first reg.present(self.name, vname=vname, vdata=vdata, vtype=vtype) expected = { 'comment': '{0} in {1} is already present'.format(vname, self.name), 'pchanges': {}, 'changes': {}, 'name': self.name, 'result': True } ret = reg.present(self.name, vname=vname, vdata=vdata, vtype=vtype) self.assertDictEqual(ret, expected)
def test_present(self): ''' Test to set a registry entry. ''' name = 'HKEY_CURRENT_USER\\SOFTWARE\\Salt' vname = 'version' vdata = '0.15.3' ret = {'name': name, 'changes': {}, 'result': True, 'comment': '{0} in {1} is already configured'.format(vname, name)} mock_read = MagicMock(side_effect=[{'vdata': vdata, 'success': True}, {'vdata': 'a', 'success': True}, {'vdata': 'a', 'success': True}]) mock_t = MagicMock(return_value=True) with patch.dict(reg.__salt__, {'reg.read_value': mock_read, 'reg.set_value': mock_t}): self.assertDictEqual(reg.present(name, vname=vname, vdata=vdata), ret) with patch.dict(reg.__opts__, {'test': True}): ret.update({'comment': '', 'result': None, 'changes': {'reg': {'Will add': {'Key': name, 'Entry': vname, 'Value': vdata}}}}) self.assertDictEqual(reg.present(name, vname=vname, vdata=vdata), ret) with patch.dict(reg.__opts__, {'test': False}): ret.update({'comment': 'Added {0} to {0}'.format(name), 'result': True, 'changes': {'reg': {'Added': {'Key': name, 'Entry': vname, 'Value': vdata}}}}) self.assertDictEqual(reg.present(name, vname=vname, vdata=vdata), ret)
def test_present_existing(reg_vars, reset): expected = { "comment": "{} in {} is already present".format(reg_vars.vname, reg_vars.name), "changes": {}, "name": reg_vars.name, "result": True, } assert (reg.present(name=reg_vars.name, vname=reg_vars.vname, vdata=reg_vars.vdata) == expected)
def test_present_existing_key_only(reg_vars, clean): """ Test setting only a key with no value name """ # Create the reg key for testing reg_util.set_value(hive=reg_vars.hive, key=reg_vars.key) expected = { "comment": "(Default) in {} is already present".format(reg_vars.name), "changes": {}, "name": reg_vars.name, "result": True, } assert reg.present(reg_vars.name) == expected
def test_present_existing_test_true(reg_vars, reset): expected = { "comment": "{} in {} is already present".format(reg_vars.vname, reg_vars.name), "changes": {}, "name": reg_vars.name, "result": True, } with patch.dict(reg.__opts__, {"test": True}): ret = reg.present(name=reg_vars.name, vname=reg_vars.vname, vdata=reg_vars.vdata) assert ret == expected
def test_present_existing_key_only(self): """ Test setting only a key with no value name """ # Create the reg key for testing salt.utils.win_reg.set_value(hive=self.hive, key=self.key) expected = { "comment": "(Default) in {0} is already present".format(self.name), "changes": {}, "name": self.name, "result": True, } ret = reg.present(self.name) self.assertDictEqual(ret, expected)
def test_present_existing(self): # Create the reg key for testing salt.utils.win_reg.set_value(hive=self.hive, key=self.key, vname=self.vname, vdata=self.vdata) expected = { "comment": "{} in {} is already present".format(self.vname, self.name), "changes": {}, "name": self.name, "result": True, } ret = reg.present(self.name, vname=self.vname, vdata=self.vdata) self.assertDictEqual(ret, expected)
def test_present_existing(self): # Create the reg key for testing salt.utils.win_reg.set_value(hive=self.hive, key=self.key, vname=self.vname, vdata=self.vdata) expected = { 'comment': '{0} in {1} is already present'.format(self.vname, self.name), 'changes': {}, 'name': self.name, 'result': True } ret = reg.present(self.name, vname=self.vname, vdata=self.vdata) self.assertDictEqual(ret, expected)
def test_present_existing_test_true(self): # Create the reg key for testing salt.utils.win_reg.set_value(hive=self.hive, key=self.key, vname=self.vname, vdata=self.vdata) expected = { "comment": "{0} in {1} is already present".format(self.vname, self.name), "pchanges": {}, "changes": {}, "name": self.name, "result": True, } with patch.dict(reg.__opts__, {"test": True}): ret = reg.present(self.name, vname=self.vname, vdata=self.vdata) self.assertDictEqual(ret, expected)
def test_present_string_dword_existing(reg_vars, clean): """ Test to set a registry entry. """ vname = "dword_data" vdata = "0000001" vtype = "REG_DWORD" # Set it first reg_util.set_value(hive=reg_vars.hive, key=reg_vars.key, vname=vname, vdata=vdata, vtype=vtype) expected = { "comment": "{} in {} is already present".format(vname, reg_vars.name), "changes": {}, "name": reg_vars.name, "result": True, } assert (reg.present(name=reg_vars.name, vname=vname, vdata=vdata, vtype=vtype) == expected)