"""
Tests for win_path states
"""

import copy

import pytest

import salt.states.win_path as win_path
from tests.support.mock import MagicMock, Mock, patch


@pytest.fixture
def name():
    return "salt"


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


def test_absent(name):
    """
    Test various cases for win_path.absent
    """
    ret_base = {"name": name, "result": True, "changes": {}}

    def _mock(retval):
        # Return a new MagicMock for each test case
        return MagicMock(side_effect=retval)

    # We don't really want to run the remove func
    with patch.dict(win_path.__salt__, {"win_path.remove": Mock()}):

        # Test mode OFF
        with patch.dict(win_path.__opts__, {"test": False}):

            # Test already absent
            with patch.dict(win_path.__salt__, {"win_path.exists": _mock([False])}):
                ret = copy.deepcopy(ret_base)
                ret["comment"] = "{} is not in the PATH".format(name)
                ret["result"] = True
                assert win_path.absent(name) == ret

            # Test successful removal
            with patch.dict(
                win_path.__salt__, {"win_path.exists": _mock([True, False])}
            ):
                ret = copy.deepcopy(ret_base)
                ret["comment"] = "Removed {} from the PATH".format(name)
                ret["changes"]["removed"] = name
                ret["result"] = True
                assert win_path.absent(name) == ret

            # Test unsucessful removal
            with patch.dict(
                win_path.__salt__, {"win_path.exists": _mock([True, True])}
            ):
                ret = copy.deepcopy(ret_base)
                ret["comment"] = "Failed to remove {} from the PATH".format(name)
                ret["result"] = False
                assert win_path.absent(name) == ret

        # Test mode ON
        with patch.dict(win_path.__opts__, {"test": True}):

            # Test already absent
            with patch.dict(win_path.__salt__, {"win_path.exists": _mock([False])}):
                ret = copy.deepcopy(ret_base)
                ret["comment"] = "{} is not in the PATH".format(name)
                ret["result"] = True
                assert win_path.absent(name) == ret

            # Test the test-mode return
            with patch.dict(win_path.__salt__, {"win_path.exists": _mock([True])}):
                ret = copy.deepcopy(ret_base)
                ret["comment"] = "{} would be removed from the PATH".format(name)
                ret["result"] = None
                assert win_path.absent(name) == ret


def test_exists_invalid_index(name):
    """
    Tests win_path.exists when a non-integer index is specified.
    """
    ret = win_path.exists(name, index="foo")
    assert ret == {
        "name": name,
        "changes": {},
        "result": False,
        "comment": "Index must be an integer",
    }


def test_exists_add_no_index_success(name):
    """
    Tests win_path.exists when the directory isn't already in the PATH and
    no index is specified (successful run).
    """
    add_mock = MagicMock(return_value=True)
    rehash_mock = MagicMock(return_value=True)
    dunder_salt = {
        "win_path.get_path": MagicMock(
            side_effect=[["foo", "bar", "baz"], ["foo", "bar", "baz", name]]
        ),
        "win_path.add": add_mock,
        "win_path.rehash": rehash_mock,
    }
    dunder_opts = {"test": False}

    with patch.dict(win_path.__salt__, dunder_salt), patch.dict(
        win_path.__opts__, dunder_opts
    ):
        ret = win_path.exists(name)

    add_mock.assert_called_once_with(name, index=None, rehash=False)
    rehash_mock.assert_called_once_with()
    assert ret == {
        "name": name,
        "changes": {"index": {"old": None, "new": 3}},
        "result": True,
        "comment": "Added {} to the PATH.".format(name),
    }


def test_exists_add_no_index_failure(name):
    """
    Tests win_path.exists when the directory isn't already in the PATH and
    no index is specified (failed run).
    """
    add_mock = MagicMock(return_value=False)
    rehash_mock = MagicMock(return_value=True)
    dunder_salt = {
        "win_path.get_path": MagicMock(
            side_effect=[["foo", "bar", "baz"], ["foo", "bar", "baz"]]
        ),
        "win_path.add": add_mock,
        "win_path.rehash": rehash_mock,
    }
    dunder_opts = {"test": False}

    with patch.dict(win_path.__salt__, dunder_salt), patch.dict(
        win_path.__opts__, dunder_opts
    ):
        ret = win_path.exists(name)

    add_mock.assert_called_once_with(name, index=None, rehash=False)
    rehash_mock.assert_not_called()
    assert ret == {
        "name": name,
        "changes": {},
        "result": False,
        "comment": "Failed to add {} to the PATH.".format(name),
    }


def test_exists_add_no_index_failure_exception(name):
    """
    Tests win_path.exists when the directory isn't already in the PATH and
    no index is specified (failed run due to exception).
    """
    add_mock = MagicMock(side_effect=Exception("Global Thermonuclear War"))
    rehash_mock = MagicMock(return_value=True)
    dunder_salt = {
        "win_path.get_path": MagicMock(
            side_effect=[["foo", "bar", "baz"], ["foo", "bar", "baz"]]
        ),
        "win_path.add": add_mock,
        "win_path.rehash": rehash_mock,
    }
    dunder_opts = {"test": False}

    with patch.dict(win_path.__salt__, dunder_salt), patch.dict(
        win_path.__opts__, dunder_opts
    ):
        ret = win_path.exists(name)

    add_mock.assert_called_once_with(name, index=None, rehash=False)
    rehash_mock.assert_not_called()
    assert ret == {
        "name": name,
        "changes": {},
        "result": False,
        "comment": (
            "Encountered error: Global Thermonuclear War. "
            "Failed to add {} to the PATH.".format(name)
        ),
    }


def test_exists_change_index_success(name):
    """
    Tests win_path.exists when the directory is already in the PATH and
    needs to be moved to a different position (successful run).
    """
    add_mock = MagicMock(return_value=True)
    rehash_mock = MagicMock(return_value=True)
    dunder_salt = {
        "win_path.get_path": MagicMock(
            side_effect=[["foo", "bar", "baz", name], [name, "foo", "bar", "baz"]]
        ),
        "win_path.add": add_mock,
        "win_path.rehash": rehash_mock,
    }
    dunder_opts = {"test": False}

    with patch.dict(win_path.__salt__, dunder_salt), patch.dict(
        win_path.__opts__, dunder_opts
    ):
        ret = win_path.exists(name, index=0)

    add_mock.assert_called_once_with(name, index=0, rehash=False)
    rehash_mock.assert_called_once()
    assert ret == {
        "name": name,
        "changes": {"index": {"old": 3, "new": 0}},
        "result": True,
        "comment": "Moved {} from index 3 to 0.".format(name),
    }


def test_exists_change_negative_index_success(name):
    """
    Tests win_path.exists when the directory is already in the PATH and
    needs to be moved to a different position (successful run).

    This tests a negative index.
    """
    add_mock = MagicMock(return_value=True)
    rehash_mock = MagicMock(return_value=True)
    dunder_salt = {
        "win_path.get_path": MagicMock(
            side_effect=[["foo", "bar", name, "baz"], ["foo", "bar", "baz", name]]
        ),
        "win_path.add": add_mock,
        "win_path.rehash": rehash_mock,
    }
    dunder_opts = {"test": False}

    with patch.dict(win_path.__salt__, dunder_salt), patch.dict(
        win_path.__opts__, dunder_opts
    ):
        ret = win_path.exists(name, index=-1)

    add_mock.assert_called_once_with(name, index=-1, rehash=False)
    rehash_mock.assert_called_once()
    assert ret == {
        "name": name,
        "changes": {"index": {"old": -2, "new": -1}},
        "result": True,
        "comment": "Moved {} from index -2 to -1.".format(name),
    }


def test_exists_change_index_add_exception(name):
    """
    Tests win_path.exists when the directory is already in the PATH but an
    exception is raised when we attempt to add the key to its new location.
    """
    add_mock = MagicMock(side_effect=Exception("Global Thermonuclear War"))
    rehash_mock = MagicMock(return_value=True)
    dunder_salt = {
        "win_path.get_path": MagicMock(
            side_effect=[["foo", "bar", "baz", name], ["foo", "bar", "baz", name]]
        ),
        "win_path.add": add_mock,
        "win_path.rehash": rehash_mock,
    }
    dunder_opts = {"test": False}

    with patch.dict(win_path.__salt__, dunder_salt), patch.dict(
        win_path.__opts__, dunder_opts
    ):
        ret = win_path.exists(name, index=0)

    add_mock.assert_called_once_with(name, index=0, rehash=False)
    rehash_mock.assert_not_called()
    assert ret == {
        "name": name,
        "changes": {},
        "result": False,
        "comment": (
            "Encountered error: Global Thermonuclear War. "
            "Failed to move {} from index 3 to 0.".format(name)
        ),
    }


def test_exists_change_negative_index_add_exception(name):
    """
    Tests win_path.exists when the directory is already in the PATH but an
    exception is raised when we attempt to add the key to its new location.

    This tests a negative index.
    """
    add_mock = MagicMock(side_effect=Exception("Global Thermonuclear War"))
    rehash_mock = MagicMock(return_value=True)
    dunder_salt = {
        "win_path.get_path": MagicMock(
            side_effect=[["foo", "bar", name, "baz"], ["foo", "bar", name, "baz"]]
        ),
        "win_path.add": add_mock,
        "win_path.rehash": rehash_mock,
    }
    dunder_opts = {"test": False}

    with patch.dict(win_path.__salt__, dunder_salt), patch.dict(
        win_path.__opts__, dunder_opts
    ):
        ret = win_path.exists(name, index=-1)

    add_mock.assert_called_once_with(name, index=-1, rehash=False)
    rehash_mock.assert_not_called()
    assert ret == {
        "name": name,
        "changes": {},
        "result": False,
        "comment": (
            "Encountered error: Global Thermonuclear War. "
            "Failed to move {} from index -2 to -1.".format(name)
        ),
    }


def test_exists_change_index_failure(name):
    """
    Tests win_path.exists when the directory is already in the PATH and
    needs to be moved to a different position (failed run).
    """
    add_mock = MagicMock(return_value=False)
    rehash_mock = MagicMock(return_value=True)
    dunder_salt = {
        "win_path.get_path": MagicMock(
            side_effect=[["foo", "bar", "baz", name], ["foo", "bar", "baz", name]]
        ),
        "win_path.add": add_mock,
        "win_path.rehash": rehash_mock,
    }
    dunder_opts = {"test": False}

    with patch.dict(win_path.__salt__, dunder_salt), patch.dict(
        win_path.__opts__, dunder_opts
    ):
        ret = win_path.exists(name, index=0)

    add_mock.assert_called_once_with(name, index=0, rehash=False)
    rehash_mock.assert_not_called()
    assert ret == {
        "name": name,
        "changes": {},
        "result": False,
        "comment": "Failed to move {} from index 3 to 0.".format(name),
    }


def test_exists_change_negative_index_failure(name):
    """
    Tests win_path.exists when the directory is already in the PATH and
    needs to be moved to a different position (failed run).

    This tests a negative index.
    """
    add_mock = MagicMock(return_value=False)
    rehash_mock = MagicMock(return_value=True)
    dunder_salt = {
        "win_path.get_path": MagicMock(
            side_effect=[["foo", "bar", name, "baz"], ["foo", "bar", name, "baz"]]
        ),
        "win_path.add": add_mock,
        "win_path.rehash": rehash_mock,
    }
    dunder_opts = {"test": False}

    with patch.dict(win_path.__salt__, dunder_salt), patch.dict(
        win_path.__opts__, dunder_opts
    ):
        ret = win_path.exists(name, index=-1)

    add_mock.assert_called_once_with(name, index=-1, rehash=False)
    rehash_mock.assert_not_called()
    assert ret == {
        "name": name,
        "changes": {},
        "result": False,
        "comment": "Failed to move {} from index -2 to -1.".format(name),
    }


def test_exists_change_index_test_mode(name):
    """
    Tests win_path.exists when the directory is already in the PATH and
    needs to be moved to a different position (test mode enabled).
    """
    add_mock = Mock()
    rehash_mock = MagicMock(return_value=True)
    dunder_salt = {
        "win_path.get_path": MagicMock(side_effect=[["foo", "bar", "baz", name]]),
        "win_path.add": add_mock,
        "win_path.rehash": rehash_mock,
    }
    dunder_opts = {"test": True}

    with patch.dict(win_path.__salt__, dunder_salt), patch.dict(
        win_path.__opts__, dunder_opts
    ):
        ret = win_path.exists(name, index=0)

    add_mock.assert_not_called()
    rehash_mock.assert_not_called()
    assert ret == {
        "name": name,
        "changes": {"index": {"old": 3, "new": 0}},
        "result": None,
        "comment": "{} would be moved from index 3 to 0.".format(name),
    }


def test_exists_change_negative_index_test_mode(name):
    """
    Tests win_path.exists when the directory is already in the PATH and
    needs to be moved to a different position (test mode enabled).
    """
    add_mock = Mock()
    rehash_mock = MagicMock(return_value=True)
    dunder_salt = {
        "win_path.get_path": MagicMock(side_effect=[["foo", "bar", name, "baz"]]),
        "win_path.add": add_mock,
        "win_path.rehash": rehash_mock,
    }
    dunder_opts = {"test": True}

    with patch.dict(win_path.__salt__, dunder_salt), patch.dict(
        win_path.__opts__, dunder_opts
    ):
        ret = win_path.exists(name, index=-1)

    add_mock.assert_not_called()
    rehash_mock.assert_not_called()
    assert ret == {
        "name": name,
        "changes": {"index": {"old": -2, "new": -1}},
        "result": None,
        "comment": "{} would be moved from index -2 to -1.".format(name),
    }


def _test_exists_add_already_present(index, test_mode, name):
    """
    Tests win_path.exists when the directory already exists in the PATH.
    Helper function to test both with and without and index, and with test
    mode both disabled and enabled.
    """
    current_path = ["foo", "bar", "baz"]
    if index is None:
        current_path.append(name)
    else:
        pos = index if index >= 0 else len(current_path) + index + 1
        current_path.insert(pos, name)

    add_mock = Mock()
    rehash_mock = MagicMock(return_value=True)
    dunder_salt = {
        "win_path.get_path": MagicMock(side_effect=[current_path]),
        "win_path.add": add_mock,
        "win_path.rehash": rehash_mock,
    }
    dunder_opts = {"test": test_mode}

    with patch.dict(win_path.__salt__, dunder_salt), patch.dict(
        win_path.__opts__, dunder_opts
    ):
        ret = win_path.exists(name, index=index)

    add_mock.assert_not_called()
    rehash_mock.assert_not_called()
    assert ret == {
        "name": name,
        "changes": {},
        "result": True,
        "comment": "{} already exists in the PATH{}.".format(
            name, " at index {}".format(index) if index is not None else ""
        ),
    }


def test_exists_add_no_index_already_present(name):
    _test_exists_add_already_present(None, False, name)


def test_exists_add_no_index_already_present_test_mode(name):
    _test_exists_add_already_present(None, True, name)


def test_exists_add_index_already_present(name):
    _test_exists_add_already_present(1, False, name)
    _test_exists_add_already_present(2, False, name)
    _test_exists_add_already_present(-1, False, name)
    _test_exists_add_already_present(-2, False, name)


def test_exists_add_index_already_present_test_mode(name):
    _test_exists_add_already_present(1, True, name)
    _test_exists_add_already_present(2, True, name)
    _test_exists_add_already_present(-1, True, name)
    _test_exists_add_already_present(-2, True, name)
