mirror of
https://github.com/valitydev/salt.git
synced 2024-11-07 17:09:03 +00:00
522 lines
18 KiB
Python
522 lines
18 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
# Import Python libs
|
|
from __future__ import absolute_import
|
|
|
|
# Import Salt Libs
|
|
import salt.states.win_dism as dism
|
|
|
|
# Import Salt Testing Libs
|
|
from tests.support.mixins import LoaderModuleMockMixin
|
|
from tests.support.unit import TestCase
|
|
from tests.support.mock import (
|
|
MagicMock,
|
|
patch
|
|
)
|
|
|
|
|
|
class WinDismTestCase(TestCase, LoaderModuleMockMixin):
|
|
|
|
def setup_loader_modules(self):
|
|
return {dism: {}}
|
|
|
|
def test_capability_installed(self):
|
|
'''
|
|
Test capability installed state
|
|
'''
|
|
expected = {
|
|
'comment': "Installed Capa2",
|
|
'changes': {'capability': {'new': 'Capa2'},
|
|
'retcode': 0},
|
|
'name': 'Capa2',
|
|
'result': True}
|
|
|
|
mock_installed = MagicMock(
|
|
side_effect=[['Capa1'], ['Capa1', 'Capa2']])
|
|
mock_add = MagicMock(
|
|
return_value={'retcode': 0})
|
|
|
|
with patch.dict(
|
|
dism.__salt__, {'dism.installed_capabilities': mock_installed,
|
|
'dism.add_capability': mock_add}):
|
|
with patch.dict(dism.__opts__, {'test': False}):
|
|
|
|
out = dism.capability_installed('Capa2', 'somewhere', True)
|
|
|
|
mock_installed.assert_called_with()
|
|
mock_add.assert_called_once_with(
|
|
'Capa2', 'somewhere', True, None, False)
|
|
self.assertEqual(out, expected)
|
|
|
|
def test_capability_installed_failure(self):
|
|
'''
|
|
Test installing a capability which fails with DISM
|
|
'''
|
|
expected = {
|
|
'comment': "Failed to install Capa2: Failed",
|
|
'changes': {},
|
|
'name': 'Capa2',
|
|
'result': False}
|
|
|
|
mock_installed = MagicMock(
|
|
side_effect=[['Capa1'], ['Capa1']])
|
|
mock_add = MagicMock(
|
|
return_value={'retcode': 67, 'stdout': 'Failed'})
|
|
|
|
with patch.dict(
|
|
dism.__salt__, {'dism.installed_capabilities': mock_installed,
|
|
'dism.add_capability': mock_add}):
|
|
with patch.dict(dism.__opts__, {'test': False}):
|
|
|
|
out = dism.capability_installed('Capa2', 'somewhere', True)
|
|
|
|
mock_installed.assert_called_with()
|
|
mock_add.assert_called_once_with(
|
|
'Capa2', 'somewhere', True, None, False)
|
|
self.assertEqual(out, expected)
|
|
|
|
def test_capability_installed_installed(self):
|
|
'''
|
|
Test installing a capability already installed
|
|
'''
|
|
expected = {
|
|
'comment': "The capability Capa2 is already installed",
|
|
'changes': {},
|
|
'name': 'Capa2',
|
|
'result': True}
|
|
|
|
mock_installed = MagicMock(
|
|
return_value=["Capa1", "Capa2"])
|
|
mock_add = MagicMock()
|
|
|
|
with patch.dict(
|
|
dism.__salt__, {'dism.installed_capabilities': mock_installed,
|
|
'dism.add_capability': mock_add}):
|
|
|
|
with patch.dict(dism.__opts__, {'test': False}):
|
|
out = dism.capability_installed('Capa2', 'somewhere', True)
|
|
|
|
mock_installed.assert_called_once_with()
|
|
assert not mock_add.called
|
|
self.assertEqual(out, expected)
|
|
|
|
def test_capability_removed(self):
|
|
'''
|
|
Test capability removed state
|
|
'''
|
|
expected = {
|
|
'comment': "Removed Capa2",
|
|
'changes': {'capability': {'old': 'Capa2'},
|
|
'retcode': 0},
|
|
'name': 'Capa2',
|
|
'result': True}
|
|
|
|
mock_removed = MagicMock(
|
|
side_effect=[['Capa1', 'Capa2'], ['Capa1']])
|
|
mock_remove = MagicMock(
|
|
return_value={'retcode': 0})
|
|
|
|
with patch.dict(
|
|
dism.__salt__, {'dism.installed_capabilities': mock_removed,
|
|
'dism.remove_capability': mock_remove}):
|
|
with patch.dict(dism.__opts__, {'test': False}):
|
|
|
|
out = dism.capability_removed('Capa2')
|
|
|
|
mock_removed.assert_called_with()
|
|
mock_remove.assert_called_once_with('Capa2', None, False)
|
|
self.assertEqual(out, expected)
|
|
|
|
def test_capability_removed_failure(self):
|
|
'''
|
|
Test removing a capability which fails with DISM
|
|
'''
|
|
expected = {
|
|
'comment': "Failed to remove Capa2: Failed",
|
|
'changes': {},
|
|
'name': 'Capa2',
|
|
'result': False}
|
|
|
|
mock_removed = MagicMock(
|
|
side_effect=[['Capa1', 'Capa2'], ['Capa1', 'Capa2']])
|
|
mock_remove = MagicMock(
|
|
return_value={'retcode': 67, 'stdout': 'Failed'})
|
|
|
|
with patch.dict(
|
|
dism.__salt__, {'dism.installed_capabilities': mock_removed,
|
|
'dism.remove_capability': mock_remove}):
|
|
with patch.dict(dism.__opts__, {'test': False}):
|
|
|
|
out = dism.capability_removed('Capa2')
|
|
|
|
mock_removed.assert_called_with()
|
|
mock_remove.assert_called_once_with(
|
|
'Capa2', None, False)
|
|
self.assertEqual(out, expected)
|
|
|
|
def test_capability_removed_removed(self):
|
|
'''
|
|
Test removing a capability already removed
|
|
'''
|
|
expected = {
|
|
'comment': "The capability Capa2 is already removed",
|
|
'changes': {},
|
|
'name': 'Capa2',
|
|
'result': True}
|
|
|
|
mock_removed = MagicMock(
|
|
return_value=["Capa1"])
|
|
mock_remove = MagicMock()
|
|
|
|
with patch.dict(
|
|
dism.__salt__, {'dism.installed_capabilities': mock_removed,
|
|
'dism.add_capability': mock_remove}):
|
|
|
|
out = dism.capability_removed('Capa2', 'somewhere', True)
|
|
|
|
mock_removed.assert_called_once_with()
|
|
assert not mock_remove.called
|
|
self.assertEqual(out, expected)
|
|
|
|
def test_feature_installed(self):
|
|
'''
|
|
Test installing a feature with DISM
|
|
'''
|
|
expected = {
|
|
'comment': "Installed Feat2",
|
|
'changes': {'feature': {'new': 'Feat2'},
|
|
'retcode': 0},
|
|
'name': 'Feat2',
|
|
'result': True}
|
|
|
|
mock_installed = MagicMock(
|
|
side_effect=[['Feat1'], ['Feat1', 'Feat2']])
|
|
mock_add = MagicMock(
|
|
return_value={'retcode': 0})
|
|
|
|
with patch.dict(
|
|
dism.__salt__, {'dism.installed_features': mock_installed,
|
|
'dism.add_feature': mock_add}):
|
|
with patch.dict(dism.__opts__, {'test': False}):
|
|
|
|
out = dism.feature_installed('Feat2')
|
|
|
|
mock_installed.assert_called_with()
|
|
mock_add.assert_called_once_with(
|
|
'Feat2', None, None, False, False, None, False)
|
|
self.assertEqual(out, expected)
|
|
|
|
def test_feature_installed_failure(self):
|
|
'''
|
|
Test installing a feature which fails with DISM
|
|
'''
|
|
expected = {
|
|
'comment': "Failed to install Feat2: Failed",
|
|
'changes': {},
|
|
'name': 'Feat2',
|
|
'result': False}
|
|
|
|
mock_installed = MagicMock(
|
|
side_effect=[['Feat1'], ['Feat1']])
|
|
mock_add = MagicMock(
|
|
return_value={'retcode': 67, 'stdout': 'Failed'})
|
|
|
|
with patch.dict(
|
|
dism.__salt__, {'dism.installed_features': mock_installed,
|
|
'dism.add_feature': mock_add}):
|
|
with patch.dict(dism.__opts__, {'test': False}):
|
|
|
|
out = dism.feature_installed('Feat2')
|
|
|
|
mock_installed.assert_called_with()
|
|
mock_add.assert_called_once_with(
|
|
'Feat2', None, None, False, False, None, False)
|
|
self.assertEqual(out, expected)
|
|
|
|
def test_feature_installed_installed(self):
|
|
'''
|
|
Test installing a feature already installed
|
|
'''
|
|
expected = {
|
|
'comment': "The feature Feat1 is already installed",
|
|
'changes': {},
|
|
'name': 'Feat1',
|
|
'result': True}
|
|
|
|
mock_installed = MagicMock(
|
|
side_effect=[['Feat1', 'Feat2'], ['Feat1', 'Feat2']])
|
|
mock_add = MagicMock()
|
|
|
|
with patch.dict(
|
|
dism.__salt__, {'dism.installed_features': mock_installed,
|
|
'dism.add_feature': mock_add}):
|
|
|
|
out = dism.feature_installed('Feat1')
|
|
|
|
mock_installed.assert_called_once_with()
|
|
assert not mock_add.called
|
|
self.assertEqual(out, expected)
|
|
|
|
def test_feature_removed(self):
|
|
'''
|
|
Test removing a feature with DISM
|
|
'''
|
|
expected = {
|
|
'comment': "Removed Feat2",
|
|
'changes': {'feature': {'old': 'Feat2'},
|
|
'retcode': 0},
|
|
'name': 'Feat2',
|
|
'result': True}
|
|
|
|
mock_removed = MagicMock(
|
|
side_effect=[['Feat1', 'Feat2'], ['Feat1']])
|
|
mock_remove = MagicMock(
|
|
return_value={'retcode': 0})
|
|
|
|
with patch.dict(
|
|
dism.__salt__, {'dism.installed_features': mock_removed,
|
|
'dism.remove_feature': mock_remove}):
|
|
with patch.dict(dism.__opts__, {'test': False}):
|
|
|
|
out = dism.feature_removed('Feat2')
|
|
|
|
mock_removed.assert_called_with()
|
|
mock_remove.assert_called_once_with(
|
|
'Feat2', False, None, False)
|
|
self.assertEqual(out, expected)
|
|
|
|
def test_feature_removed_failure(self):
|
|
'''
|
|
Test removing a feature which fails with DISM
|
|
'''
|
|
expected = {
|
|
'comment': "Failed to remove Feat2: Failed",
|
|
'changes': {},
|
|
'name': 'Feat2',
|
|
'result': False}
|
|
|
|
mock_removed = MagicMock(
|
|
side_effect=[['Feat1', 'Feat2'], ['Feat1', 'Feat2']])
|
|
mock_remove = MagicMock(
|
|
return_value={'retcode': 67, 'stdout': 'Failed'})
|
|
|
|
with patch.dict(
|
|
dism.__salt__, {'dism.installed_features': mock_removed,
|
|
'dism.remove_feature': mock_remove}):
|
|
with patch.dict(dism.__opts__, {'test': False}):
|
|
|
|
out = dism.feature_removed('Feat2')
|
|
|
|
mock_removed.assert_called_with()
|
|
mock_remove.assert_called_once_with(
|
|
'Feat2', False, None, False)
|
|
self.assertEqual(out, expected)
|
|
|
|
def test_feature_removed_removed(self):
|
|
'''
|
|
Test removing a feature already removed
|
|
'''
|
|
expected = {
|
|
'comment': "The feature Feat2 is already removed",
|
|
'changes': {},
|
|
'name': 'Feat2',
|
|
'result': True}
|
|
|
|
mock_removed = MagicMock(
|
|
side_effect=[['Feat1'], ['Feat1']])
|
|
mock_remove = MagicMock()
|
|
|
|
with patch.dict(
|
|
dism.__salt__, {'dism.installed_features': mock_removed,
|
|
'dism.remove_feature': mock_remove}):
|
|
|
|
out = dism.feature_removed('Feat2')
|
|
|
|
mock_removed.assert_called_once_with()
|
|
assert not mock_remove.called
|
|
self.assertEqual(out, expected)
|
|
|
|
def test_package_installed(self):
|
|
'''
|
|
Test installing a package with DISM
|
|
'''
|
|
expected = {
|
|
'comment': "Installed Pack2",
|
|
'changes': {'package': {'new': 'Pack2'},
|
|
'retcode': 0},
|
|
'name': 'Pack2',
|
|
'result': True}
|
|
|
|
mock_installed = MagicMock(
|
|
side_effect=[['Pack1'], ['Pack1', 'Pack2']])
|
|
mock_add = MagicMock(
|
|
return_value={'retcode': 0})
|
|
mock_info = MagicMock(
|
|
return_value={'Package Identity': 'Pack2'})
|
|
|
|
with patch.dict(
|
|
dism.__salt__, {'dism.installed_packages': mock_installed,
|
|
'dism.add_package': mock_add,
|
|
'dism.package_info': mock_info}):
|
|
with patch.dict(dism.__opts__, {'test': False}):
|
|
with patch('os.path.exists'):
|
|
|
|
out = dism.package_installed('Pack2')
|
|
|
|
mock_installed.assert_called_with()
|
|
mock_add.assert_called_once_with(
|
|
'Pack2', False, False, None, False)
|
|
self.assertEqual(out, expected)
|
|
|
|
def test_package_installed_failure(self):
|
|
'''
|
|
Test installing a package which fails with DISM
|
|
'''
|
|
expected = {
|
|
'comment': "Failed to install Pack2: Failed",
|
|
'changes': {},
|
|
'name': 'Pack2',
|
|
'result': False}
|
|
|
|
mock_installed = MagicMock(
|
|
side_effect=[['Pack1'], ['Pack1']])
|
|
mock_add = MagicMock(
|
|
return_value={'retcode': 67, 'stdout': 'Failed'})
|
|
mock_info = MagicMock(
|
|
return_value={'Package Identity': 'Pack2'})
|
|
|
|
with patch.dict(
|
|
dism.__salt__, {'dism.installed_packages': mock_installed,
|
|
'dism.add_package': mock_add,
|
|
'dism.package_info': mock_info}):
|
|
with patch.dict(dism.__opts__, {'test': False}):
|
|
with patch('os.path.exists'):
|
|
|
|
out = dism.package_installed('Pack2')
|
|
|
|
mock_installed.assert_called_with()
|
|
mock_add.assert_called_once_with(
|
|
'Pack2', False, False, None, False)
|
|
self.assertEqual(out, expected)
|
|
|
|
def test_package_installed_installed(self):
|
|
'''
|
|
Test installing a package already installed
|
|
'''
|
|
expected = {
|
|
'comment': "The package Pack2 is already installed: Pack2",
|
|
'changes': {},
|
|
'name': 'Pack2',
|
|
'result': True}
|
|
|
|
mock_installed = MagicMock(
|
|
side_effect=[['Pack1', 'Pack2'], ['Pack1', 'Pack2']])
|
|
mock_add = MagicMock()
|
|
mock_info = MagicMock(
|
|
return_value={'Package Identity': 'Pack2'})
|
|
|
|
with patch.dict(
|
|
dism.__salt__, {'dism.installed_packages': mock_installed,
|
|
'dism.add_package': mock_add,
|
|
'dism.package_info': mock_info}):
|
|
with patch.dict(dism.__opts__, {'test': False}):
|
|
with patch('os.path.exists'):
|
|
|
|
out = dism.package_installed('Pack2')
|
|
|
|
mock_installed.assert_called_once_with()
|
|
assert not mock_add.called
|
|
self.assertEqual(out, expected)
|
|
|
|
def test_package_removed(self):
|
|
'''
|
|
Test removing a package with DISM
|
|
'''
|
|
expected = {
|
|
'comment': "Removed Pack2",
|
|
'changes': {'package': {'old': 'Pack2'},
|
|
'retcode': 0},
|
|
'name': 'Pack2',
|
|
'result': True}
|
|
|
|
mock_removed = MagicMock(
|
|
side_effect=[['Pack1', 'Pack2'], ['Pack1']])
|
|
mock_remove = MagicMock(
|
|
return_value={'retcode': 0})
|
|
mock_info = MagicMock(
|
|
return_value={'Package Identity': 'Pack2'})
|
|
|
|
with patch.dict(
|
|
dism.__salt__, {'dism.installed_packages': mock_removed,
|
|
'dism.remove_package': mock_remove,
|
|
'dism.package_info': mock_info}):
|
|
with patch.dict(dism.__opts__, {'test': False}):
|
|
with patch('os.path.exists'):
|
|
|
|
out = dism.package_removed('Pack2')
|
|
|
|
mock_removed.assert_called_with()
|
|
mock_remove.assert_called_once_with(
|
|
'Pack2', None, False)
|
|
self.assertEqual(out, expected)
|
|
|
|
def test_package_removed_failure(self):
|
|
'''
|
|
Test removing a package which fails with DISM
|
|
'''
|
|
expected = {
|
|
'comment': "Failed to remove Pack2: Failed",
|
|
'changes': {},
|
|
'name': 'Pack2',
|
|
'result': False}
|
|
|
|
mock_removed = MagicMock(
|
|
side_effect=[['Pack1', 'Pack2'], ['Pack1', 'Pack2']])
|
|
mock_remove = MagicMock(
|
|
return_value={'retcode': 67, 'stdout': 'Failed'})
|
|
mock_info = MagicMock(
|
|
return_value={'Package Identity': 'Pack2'})
|
|
|
|
with patch.dict(
|
|
dism.__salt__, {'dism.installed_packages': mock_removed,
|
|
'dism.remove_package': mock_remove,
|
|
'dism.package_info': mock_info}):
|
|
with patch.dict(dism.__opts__, {'test': False}):
|
|
with patch('os.path.exists'):
|
|
|
|
out = dism.package_removed('Pack2')
|
|
|
|
mock_removed.assert_called_with()
|
|
mock_remove.assert_called_once_with(
|
|
'Pack2', None, False)
|
|
self.assertEqual(out, expected)
|
|
|
|
def test_package_removed_removed(self):
|
|
'''
|
|
Test removing a package already removed
|
|
'''
|
|
expected = {
|
|
'comment': "The package Pack2 is already removed",
|
|
'changes': {},
|
|
'name': 'Pack2',
|
|
'result': True}
|
|
|
|
mock_removed = MagicMock(
|
|
side_effect=[['Pack1'], ['Pack1']])
|
|
mock_remove = MagicMock()
|
|
mock_info = MagicMock(
|
|
return_value={'Package Identity': 'Pack2'})
|
|
|
|
with patch.dict(
|
|
dism.__salt__, {'dism.installed_packages': mock_removed,
|
|
'dism.remove_package': mock_remove,
|
|
'dism.package_info': mock_info}):
|
|
|
|
with patch.dict(dism.__opts__, {'test': False}):
|
|
with patch('os.path.exists'):
|
|
out = dism.package_removed('Pack2')
|
|
|
|
mock_removed.assert_called_once_with()
|
|
assert not mock_remove.called
|
|
self.assertEqual(out, expected)
|