def test_absent(self):
'''
Test to remove a registry entry.
'''
name = 'HKEY_CURRENT_USER\\SOFTWARE\\Salt\\version'
ret = {'name': name,
'changes': {},
'result': True,
'comment': '{0} is already absent'.format(name)}
mock = MagicMock(side_effect=[False, True, True])
mock_t = MagicMock(return_value=True)
with patch.dict(reg.__salt__, {'reg.read_key': mock,
'reg.delete_key': mock_t}):
self.assertDictEqual(reg.absent(name), ret)
with patch.dict(reg.__opts__, {'test': True}):
ret.update({'comment': '', 'result': None,
'changes': {'reg': 'Removed {0}'.format(name)}})
self.assertDictEqual(reg.absent(name), ret)
with patch.dict(reg.__opts__, {'test': False}):
ret.update({'result': True})
self.assertDictEqual(reg.absent(name), ret)
def test_absent(self):
'''
Test to remove a registry entry.
'''
name = 'HKEY_CURRENT_USER\\SOFTWARE\\Salt\\version'
ret = {
'name': name,
'changes': {},
'result': True,
'comment': '{0} is already absent'.format(name)
}
mock = MagicMock(side_effect=[False, True, True])
mock_t = MagicMock(return_value=True)
with patch.dict(reg.__salt__, {
'reg.read_key': mock,
'reg.delete_key': mock_t
}):
self.assertDictEqual(reg.absent(name), ret)
with patch.dict(reg.__opts__, {'test': True}):
ret.update({
'comment': '',
'result': None,
'changes': {
'reg': 'Removed {0}'.format(name)
}
})
self.assertDictEqual(reg.absent(name), ret)
with patch.dict(reg.__opts__, {'test': False}):
ret.update({'result': True})
self.assertDictEqual(reg.absent(name), ret)
def test_absent_already_absent(reg_vars, clean):
"""
Test to remove a registry entry.
"""
expected = {
"comment": "{} is already absent".format(reg_vars.name),
"changes": {},
"name": reg_vars.name,
"result": True,
}
assert reg.absent(reg_vars.name, reg_vars.vname) == expected
def test_absent_already_absent(self):
"""
Test to remove a registry entry.
"""
expected = {
"comment": "{0} is already absent".format(self.name),
"changes": {},
"name": self.name,
"result": True,
}
ret = reg.absent(self.name, self.vname)
self.assertDictEqual(ret, expected)
def test_absent_already_absent(self):
'''
Test to remove a registry entry.
'''
expected = {
'comment': '{0} is already absent'.format(self.name),
'changes': {},
'name': self.name,
'result': True
}
ret = reg.absent(self.name, self.vname)
self.assertDictEqual(ret, expected)
def test_absent_already_absent_test_true(self):
"""
Test to remove a registry entry.
"""
expected = {
"comment": "{} is already absent".format(self.name),
"changes": {},
"name": self.name,
"result": True,
}
with patch.dict(reg.__opts__, {"test": True}):
ret = reg.absent(self.name, self.vname)
self.assertDictEqual(ret, expected)
def test_absent_already_absent_test_true(reg_vars, clean):
"""
Test to remove a registry entry.
"""
expected = {
"comment": "{} is already absent".format(reg_vars.name),
"changes": {},
"name": reg_vars.name,
"result": True,
}
with patch.dict(reg.__opts__, {"test": True}):
ret = reg.absent(reg_vars.name, reg_vars.vname)
assert ret == expected
def test_absent(self):
'''
Test to remove a registry entry.
'''
hive = 'HKEY_CURRENT_USER'
key = 'SOFTWARE\\Salt'
name = hive + '\\' + key
vname = 'version'
vdata = '0.15.3'
ret = {'name': name,
'changes': {},
'result': True,
'comment': '{0} is already absent'.format(name)}
mock_read_true = MagicMock(return_value={'success': True, 'vdata': vdata})
mock_read_false = MagicMock(return_value={'success': False, 'vdata': False})
mock_t = MagicMock(return_value=True)
with patch.dict(reg.__salt__, {'reg.read_value': mock_read_false,
'reg.delete_value': mock_t}):
self.assertDictEqual(reg.absent(name, vname), ret)
with patch.dict(reg.__salt__, {'reg.read_value': mock_read_true}):
with patch.dict(reg.__opts__, {'test': True}):
ret.update({'comment': '', 'result': None,
'changes': {'reg': {'Will remove': {'Entry': vname, 'Key': name}}}})
self.assertDictEqual(reg.absent(name, vname), ret)
with patch.dict(reg.__salt__, {'reg.read_value': mock_read_true,
'reg.delete_value': mock_t}):
with patch.dict(reg.__opts__, {'test': False}):
ret.update({'result': True,
'changes': {'reg': {'Removed': {'Entry': vname, 'Key': name}}},
'comment': 'Removed {0} from {1}'.format(key, hive)})
self.assertDictEqual(reg.absent(name, vname), ret)
def test_absent(self):
'''
Test to remove a registry entry.
'''
hive = 'HKEY_CURRENT_USER'
key = 'SOFTWARE\\Salt'
name = hive + '\\' + key
vname = 'version'
vdata = '0.15.3'
ret = {'name': name,
'changes': {},
'result': True,
'comment': '{0} is already absent'.format(name)}
mock_read_true = MagicMock(return_value={'success': True, 'vdata': vdata})
mock_read_false = MagicMock(return_value={'success': False, 'vdata': False})
mock_t = MagicMock(return_value=True)
with patch.dict(reg.__salt__, {'reg.read_value': mock_read_false,
'reg.delete_value': mock_t}):
self.assertDictEqual(reg.absent(name, vname), ret)
with patch.dict(reg.__salt__, {'reg.read_value': mock_read_true}):
with patch.dict(reg.__opts__, {'test': True}):
ret.update({'comment': '', 'result': None,
'changes': {'reg': {'Will remove': {'Entry': vname, 'Key': name}}}})
self.assertDictEqual(reg.absent(name, vname), ret)
with patch.dict(reg.__salt__, {'reg.read_value': mock_read_true,
'reg.delete_value': mock_t}):
with patch.dict(reg.__opts__, {'test': False}):
ret.update({'result': True,
'changes': {'reg': {'Removed': {'Entry': vname, 'Key': name}}},
'comment': 'Removed {0} from {1}'.format(key, hive)})
self.assertDictEqual(reg.absent(name, vname), ret)
def test_absent_test_true(reg_vars, reset):
expected = {
"comment": "",
"changes": {
"reg": {
"Will remove": {
"Entry": reg_vars.vname,
"Key": reg_vars.name
}
}
},
"name": reg_vars.name,
"result": None,
}
with patch.dict(reg.__opts__, {"test": True}):
ret = reg.absent(reg_vars.name, reg_vars.vname)
assert ret == expected
def test_absent(reg_vars, reset):
"""
Test to remove a registry entry.
"""
expected = {
"comment": "Removed {} from {}".format(reg_vars.key, reg_vars.hive),
"changes": {
"reg": {
"Removed": {
"Entry": reg_vars.vname,
"Key": reg_vars.name
}
}
},
"name": reg_vars.name,
"result": True,
}
assert reg.absent(reg_vars.name, reg_vars.vname) == expected
def test_absent_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": "",
"changes": {
"reg": {
"Will remove": {
"Entry": self.vname,
"Key": self.name
}
}
},
"name": self.name,
"result": None,
}
with patch.dict(reg.__opts__, {"test": True}):
ret = reg.absent(self.name, self.vname)
self.assertDictEqual(ret, expected)
def test_absent_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': '',
'changes': {
'reg': {
'Will remove': {
'Entry': self.vname,
'Key': self.name
}
}
},
'name': self.name,
'result': None
}
with patch.dict(reg.__opts__, {'test': True}):
ret = reg.absent(self.name, self.vname)
self.assertDictEqual(ret, expected)
def test_absent(self):
"""
Test to remove a registry entry.
"""
# 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": "Removed {0} from {1}".format(self.key, self.hive),
"changes": {
"reg": {
"Removed": {
"Entry": self.vname,
"Key": self.name
}
}
},
"name": self.name,
"result": True,
}
ret = reg.absent(self.name, self.vname)
self.assertDictEqual(ret, expected)
def test_absent(self):
'''
Test to remove a registry entry.
'''
# 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': 'Removed {0} from {1}'.format(self.key, self.hive),
'changes': {
'reg': {
'Removed': {
'Entry': self.vname,
'Key': self.name
}
}
},
'name': self.name,
'result': True
}
ret = reg.absent(self.name, self.vname)
self.assertDictEqual(ret, expected)
