Пример #1
0
    def test_deluser(self):
        '''
        Tests if specified user gets deleted from the group.
        '''
        mock_ret = MagicMock(return_value={'retcode': 0})
        mock_info = MagicMock(return_value={
            'passwd': '*',
            'gid': 0,
            'name': 'test',
            'members': ['root']
        })
        with patch.dict(groupadd.__grains__, {'kernel': 'Linux'}):
            with patch.dict(groupadd.__salt__, {
                    'cmd.retcode': mock_ret,
                    'group.info': mock_info
            }):
                self.assertFalse(groupadd.deluser('test', 'root'))

        mock_stdout = MagicMock(return_value={'cmd.run_stdout': 1})
        with patch.dict(groupadd.__grains__, {'kernel': 'OpenBSD'}):
            with patch.dict(
                    groupadd.__salt__, {
                        'cmd.retcode': mock_ret,
                        'group.info': mock_info,
                        'cmd.run_stdout': mock_stdout
                    }):
                self.assertTrue(groupadd.deluser('foo', 'root'))
Пример #2
0
    def test_deluser(self):
        '''
        Tests if specified user gets deleted from the group.
        '''
        os_version_list = [
            {'grains': {'kernel': 'Linux', 'os_family': 'RedHat', 'osmajorrelease': '5'},
             'cmd': ('gpasswd', '-d', 'root', 'test')},

            {'grains': {'kernel': 'Linux', 'os_family': 'Suse', 'osmajorrelease': '11'},
             'cmd': ('usermod', '-R', 'test', 'root')},

            {'grains': {'kernel': 'Linux'},
             'cmd': ('gpasswd', '--del', 'root', 'test')},

            {'grains': {'kernel': 'OpenBSD'},
             'cmd': 'usermod -S foo root'},
        ]

        for os_version in os_version_list:
            mock_ret = MagicMock(return_value={'retcode': 0})
            mock_stdout = MagicMock(return_value='test foo')
            mock_info = MagicMock(return_value={'passwd': '*',
                                                'gid': 0,
                                                'name': 'test',
                                                'members': ['root']})

            with patch.dict(groupadd.__grains__, os_version['grains']):
                with patch.dict(groupadd.__salt__, {'cmd.retcode': mock_ret,
                                                    'group.info': mock_info,
                                                    'cmd.run_stdout': mock_stdout}):
                    self.assertFalse(groupadd.deluser('test', 'root'))
                    groupadd.__salt__['cmd.retcode'].assert_called_once_with(os_version['cmd'], python_shell=False)
Пример #3
0
    def test_deluser(self):
        """
        Tests if specified user gets deleted from the group.
        """
        os_version_list = [
            {
                "grains": {"kernel": "Linux", "os_family": "RedHat", "osmajorrelease": "5"},
                "cmd": ("gpasswd", "-d", "root", "test"),
            },
            {
                "grains": {"kernel": "Linux", "os_family": "Suse", "osmajorrelease": "11"},
                "cmd": ("usermod", "-R", "test", "root"),
            },
            {"grains": {"kernel": "Linux"}, "cmd": ("gpasswd", "--del", "root", "test")},
            {"grains": {"kernel": "OpenBSD"}, "cmd": "usermod -S foo root"},
        ]

        for os_version in os_version_list:
            mock_ret = MagicMock(return_value={"retcode": 0})
            mock_stdout = MagicMock(return_value="test foo")
            mock_info = MagicMock(return_value={"passwd": "*", "gid": 0, "name": "test", "members": ["root"]})

            with patch.dict(groupadd.__grains__, os_version["grains"]):
                with patch.dict(
                    groupadd.__salt__, {"cmd.retcode": mock_ret, "group.info": mock_info, "cmd.run_stdout": mock_stdout}
                ):
                    self.assertFalse(groupadd.deluser("test", "root"))
                    groupadd.__salt__["cmd.retcode"].assert_called_once_with(os_version["cmd"], python_shell=False)
Пример #4
0
    def test_deluser(self):
        """
        Tests if specified user gets deleted from the group.
        """
        mock_ret = MagicMock(return_value={"retcode": 0})
        mock_info = MagicMock(return_value={"passwd": "*", "gid": 0, "name": "test", "members": ["root"]})
        with patch.dict(groupadd.__grains__, {"kernel": "Linux"}):
            with patch.dict(groupadd.__salt__, {"cmd.retcode": mock_ret, "group.info": mock_info}):
                self.assertFalse(groupadd.deluser("test", "root"))

        mock_stdout = MagicMock(return_value={"cmd.run_stdout": 1})
        with patch.dict(groupadd.__grains__, {"kernel": "OpenBSD"}):
            with patch.dict(
                groupadd.__salt__, {"cmd.retcode": mock_ret, "group.info": mock_info, "cmd.run_stdout": mock_stdout}
            ):
                self.assertTrue(groupadd.deluser("foo", "root"))
Пример #5
0
    def test_deluser(self):
        """
        Tests if specified user gets deleted from the group.
        """
        os_version_list = [
            {
                "grains": {
                    "kernel": "Linux",
                    "os_family": "RedHat",
                    "osmajorrelease": "5",
                },
                "cmd": ["gpasswd", "-d", "root", "test"],
            },
            {
                "grains": {
                    "kernel": "Linux",
                    "os_family": "Suse",
                    "osmajorrelease": "11",
                },
                "cmd": ["usermod", "-R", "test", "root"],
            },
            {
                "grains": {
                    "kernel": "Linux"
                },
                "cmd": ["gpasswd", "--del", "root", "test"],
            },
            {
                "grains": {
                    "kernel": "OpenBSD"
                },
                "cmd": ["usermod", "-S", "foo", "root"]
            },
        ]

        for os_version in os_version_list:
            mock_retcode = MagicMock(return_value=0)
            mock_stdout = MagicMock(return_value="test foo")
            mock_info = MagicMock(return_value={
                "passwd": "*",
                "gid": 0,
                "name": "test",
                "members": ["root"],
            })

            with patch.dict(groupadd.__grains__, os_version["grains"]):
                with patch.dict(
                        groupadd.__salt__,
                    {
                        "cmd.retcode": mock_retcode,
                        "group.info": mock_info,
                        "cmd.run_stdout": mock_stdout,
                    },
                ):
                    self.assertTrue(groupadd.deluser("test", "root"))
                    groupadd.__salt__["cmd.retcode"].assert_called_once_with(
                        os_version["cmd"], python_shell=False)
Пример #6
0
    def test_deluser(self):
        '''
        Tests if specified user gets deleted from the group.
        '''
        mock_ret = MagicMock(return_value={'retcode': 0})
        mock_info = MagicMock(return_value={'passwd': '*',
                                              'gid': 0,
                                              'name': 'test',
                                              'members': ['root']})
        with patch.dict(groupadd.__grains__, {'kernel': 'Linux'}):
            with patch.dict(groupadd.__salt__, {'cmd.retcode': mock_ret,
                                                'group.info': mock_info}):
                self.assertFalse(groupadd.deluser('test', 'root'))

        mock_stdout = MagicMock(return_value={'cmd.run_stdout': 1})
        with patch.dict(groupadd.__grains__, {'kernel': 'OpenBSD'}):
            with patch.dict(groupadd.__salt__, {'cmd.retcode': mock_ret,
                                                'group.info': mock_info,
                                                'cmd.run_stdout': mock_stdout}):
                self.assertTrue(groupadd.deluser('foo', 'root'))