salt/tests/unit/modules/test_composer.py

# -*- coding: utf-8 -*-
"""
    :codeauthor: Rupesh Tare <rupesht@saltstack.com>
"""

# Import Python libs
from __future__ import absolute_import, print_function, unicode_literals

# Import Salt Libs
import salt.modules.composer as composer
from salt.exceptions import (
    CommandExecutionError,
    CommandNotFoundError,
    SaltInvocationError,
)

# Import Salt Testing Libs
from tests.support.mixins import LoaderModuleMockMixin
from tests.support.mock import MagicMock, patch
from tests.support.unit import TestCase


class ComposerTestCase(TestCase, LoaderModuleMockMixin):
    """
    Test cases for salt.modules.composer
    """

    def setup_loader_modules(self):
        return {composer: {}}

    def test_install(self):
        """
        Test for Install composer dependencies for a directory.
        """

        # Test _valid_composer=False throws exception
        mock = MagicMock(return_value=False)
        with patch.object(composer, "_valid_composer", mock):
            self.assertRaises(CommandNotFoundError, composer.install, "d")

        # Test no directory specified throws exception
        mock = MagicMock(return_value=True)
        with patch.object(composer, "_valid_composer", mock):
            self.assertRaises(SaltInvocationError, composer.install, None)

        # Test `composer install` exit status != 0 throws exception
        mock = MagicMock(return_value=True)
        with patch.object(composer, "_valid_composer", mock):
            mock = MagicMock(return_value={"retcode": 1, "stderr": "A"})
            with patch.dict(composer.__salt__, {"cmd.run_all": mock}):
                self.assertRaises(CommandExecutionError, composer.install, "d")

        # Test success with quiet=True returns True
        mock = MagicMock(return_value=True)
        with patch.object(composer, "_valid_composer", mock):
            mock = MagicMock(return_value={"retcode": 0, "stderr": "A"})
            with patch.dict(composer.__salt__, {"cmd.run_all": mock}):
                self.assertTrue(
                    composer.install(
                        "dir",
                        None,
                        None,
                        None,
                        None,
                        None,
                        None,
                        None,
                        None,
                        None,
                        True,
                    )
                )

        # Test success with quiet=False returns object
        mock = MagicMock(return_value=True)
        with patch.object(composer, "_valid_composer", mock):
            rval = {"retcode": 0, "stderr": "A", "stdout": "B"}
            mock = MagicMock(return_value=rval)
            with patch.dict(composer.__salt__, {"cmd.run_all": mock}):
                self.assertEqual(composer.install("dir"), rval)

    def test_update(self):
        """
        Test for Update composer dependencies for a directory.
        """

        # Test _valid_composer=False throws exception
        mock = MagicMock(return_value=False)
        with patch.object(composer, "_valid_composer", mock):
            self.assertRaises(CommandNotFoundError, composer.update, "d")

        # Test no directory specified throws exception
        mock = MagicMock(return_value=True)
        with patch.object(composer, "_valid_composer", mock):
            mock = MagicMock(return_value=True)
            with patch.object(composer, "did_composer_install", mock):
                self.assertRaises(SaltInvocationError, composer.update, None)

        # Test update with error exit status throws exception
        mock = MagicMock(return_value=True)
        with patch.object(composer, "_valid_composer", mock):
            mock = MagicMock(return_value=True)
            with patch.object(composer, "did_composer_install", mock):
                mock = MagicMock(return_value={"retcode": 1, "stderr": "A"})
                with patch.dict(composer.__salt__, {"cmd.run_all": mock}):
                    self.assertRaises(CommandExecutionError, composer.update, "d")

        # Test update with existing vendor directory and quiet=True
        mock = MagicMock(return_value=True)
        with patch.object(composer, "_valid_composer", mock):
            mock = MagicMock(return_value=True)
            with patch.object(composer, "did_composer_install", mock):
                mock = MagicMock(return_value={"retcode": 0, "stderr": "A"})
                with patch.dict(composer.__salt__, {"cmd.run_all": mock}):
                    self.assertTrue(
                        composer.update(
                            "dir",
                            None,
                            None,
                            None,
                            None,
                            None,
                            None,
                            None,
                            None,
                            None,
                            True,
                        )
                    )

        # Test update with no vendor directory and quiet=True
        mock = MagicMock(return_value=True)
        with patch.object(composer, "_valid_composer", mock):
            mock = MagicMock(return_value=False)
            with patch.object(composer, "did_composer_install", mock):
                mock = MagicMock(return_value={"retcode": 0, "stderr": "A"})
                with patch.dict(composer.__salt__, {"cmd.run_all": mock}):
                    self.assertTrue(
                        composer.update(
                            "dir",
                            None,
                            None,
                            None,
                            None,
                            None,
                            None,
                            None,
                            None,
                            None,
                            True,
                        )
                    )

        # Test update with existing vendor directory
        mock = MagicMock(return_value=True)
        with patch.object(composer, "_valid_composer", mock):
            mock = MagicMock(return_value=True)
            with patch.object(composer, "did_composer_install", mock):
                rval = {"retcode": 0, "stderr": "A", "stdout": "B"}
                mock = MagicMock(return_value=rval)
                with patch.dict(composer.__salt__, {"cmd.run_all": mock}):
                    self.assertEqual(composer.update("dir"), rval)

        # Test update with no vendor directory
        mock = MagicMock(return_value=True)
        with patch.object(composer, "_valid_composer", mock):
            mock = MagicMock(return_value=False)
            with patch.object(composer, "did_composer_install", mock):
                rval = {"retcode": 0, "stderr": "A", "stdout": "B"}
                mock = MagicMock(return_value=rval)
                with patch.dict(composer.__salt__, {"cmd.run_all": mock}):
                    self.assertEqual(composer.update("dir"), rval)

    def test_selfupdate(self):
        """
        Test for Composer selfupdate
        """
        mock = MagicMock(return_value=False)
        with patch.object(composer, "_valid_composer", mock):
            self.assertRaises(CommandNotFoundError, composer.selfupdate)

        mock = MagicMock(return_value=True)
        with patch.object(composer, "_valid_composer", mock):
            mock = MagicMock(return_value={"retcode": 1, "stderr": "A"})
            with patch.dict(composer.__salt__, {"cmd.run_all": mock}):
                self.assertRaises(CommandExecutionError, composer.selfupdate)

        mock = MagicMock(return_value=True)
        with patch.object(composer, "_valid_composer", mock):
            mock = MagicMock(return_value={"retcode": 0, "stderr": "A"})
            with patch.dict(composer.__salt__, {"cmd.run_all": mock}):
                self.assertTrue(composer.selfupdate(quiet=True))

        mock = MagicMock(return_value=True)
        with patch.object(composer, "_valid_composer", mock):
            rval = {"retcode": 0, "stderr": "A", "stdout": "B"}
            mock = MagicMock(return_value=rval)
            with patch.dict(composer.__salt__, {"cmd.run_all": mock}):
                self.assertEqual(composer.selfupdate(), rval)