import pytest
import salt.states.win_dism as dism
from tests.support.mock import MagicMock, patch


@pytest.fixture
def configure_loader_modules():
    return {dism: {}}


def test_capability_installed():
    """
    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)
            assert out == expected


def test_capability_installed_failure():
    """
    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)
            assert out == expected


def test_capability_installed_installed():
    """
    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
            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


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_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


def test_feature_installed():
    """
    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
            )
            assert out == expected


def test_feature_installed_failure():
    """
    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
            )
            assert out == expected


def test_feature_installed_installed():
    """
    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
        assert out == expected


def test_feature_removed():
    """
    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)
            assert out == expected


def test_feature_removed_failure():
    """
    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)
            assert out == expected


def test_feature_removed_removed():
    """
    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
        assert out == expected


def test_package_installed():
    """
    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)
                assert out == expected


def test_package_installed_failure():
    """
    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)
                assert out == expected


def test_package_installed_installed():
    """
    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
                assert out == expected


def test_package_removed():
    """
    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)
                assert out == expected


def test_package_removed_failure():
    """
    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)
                assert out == expected


def test_package_removed_removed():
    """
    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
                assert out == expected
