Exemple #1
0
    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)
Exemple #2
0
    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)
Exemple #3
0
    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)