Example #1
0
    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)
Example #2
0
    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_capability_removed_removed():
    """
    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
        assert out == expected
Example #4
0
    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():
    """
    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)
            assert out == expected
def test_capability_removed():
    """
    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)
            assert out == expected
Example #7
0
    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)
Example #8
0
    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)
Example #9
0
    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)