Пример #1
0
    def test_remount_already_mounted_with_fstype(self):
        '''
        Attempt to remount a device already mounted that do not provides
        fstype
        '''
        with patch.dict(mount.__grains__, {'os': 'MacOS'}):
            mock = MagicMock(return_value=['name'])
            with patch.object(mount, 'active', mock):
                mock = MagicMock(return_value={'retcode': 0})
                with patch.dict(mount.__salt__, {'cmd.run_all': mock}):
                    self.assertTrue(mount.remount('name', 'device', fstype='type'))
                    mock.assert_called_with('mount -u -o noowners -t type device name ',
                                            python_shell=False, runas=None)

        with patch.dict(mount.__grains__, {'os': 'AIX'}):
            mock = MagicMock(return_value=['name'])
            with patch.object(mount, 'active', mock):
                mock = MagicMock(return_value={'retcode': 0})
                with patch.dict(mount.__salt__, {'cmd.run_all': mock}):
                    self.assertTrue(mount.remount('name', 'device', fstype='type'))
                    mock.assert_called_with('mount -o remount -v type device name ',
                                            python_shell=False, runas=None)

        with patch.dict(mount.__grains__, {'os': 'Linux'}):
            mock = MagicMock(return_value=['name'])
            with patch.object(mount, 'active', mock):
                mock = MagicMock(return_value={'retcode': 0})
                with patch.dict(mount.__salt__, {'cmd.run_all': mock}):
                    self.assertTrue(mount.remount('name', 'device', fstype='type'))
                    mock.assert_called_with('mount -o defaults,remount -t type device name ',
                                            python_shell=False, runas=None)
Пример #2
0
def test_remount_non_mounted():
    """
    Attempt to remount a device, if the device is not already mounted, mount
    is called
    """
    with patch.dict(mount.__grains__, {"os": "MacOS"}):
        mock = MagicMock(return_value=[])
        with patch.object(mount, "active", mock):
            mock = MagicMock(return_value=True)
            with patch.object(mount, "mount", mock):
                assert mount.remount("name", "device")

    with patch.dict(mount.__grains__, {"os": "AIX"}):
        mock = MagicMock(return_value=[])
        with patch.object(mount, "active", mock):
            mock = MagicMock(return_value=True)
            with patch.object(mount, "mount", mock):
                assert mount.remount("name", "device")

    with patch.dict(mount.__grains__, {"os": "Linux"}):
        mock = MagicMock(return_value=[])
        with patch.object(mount, "active", mock):
            mock = MagicMock(return_value=True)
            with patch.object(mount, "mount", mock):
                assert mount.remount("name", "device")
Пример #3
0
    def test_remount_non_mounted(self):
        '''
        Attempt to remount a device, if the device is not already mounted, mount
        is called
        '''
        with patch.dict(mount.__grains__, {'os': 'MacOS'}):
            mock = MagicMock(return_value=[])
            with patch.object(mount, 'active', mock):
                mock = MagicMock(return_value=True)
                with patch.object(mount, 'mount', mock):
                    self.assertTrue(mount.remount('name', 'device'))

        with patch.dict(mount.__grains__, {'os': 'AIX'}):
            mock = MagicMock(return_value=[])
            with patch.object(mount, 'active', mock):
                mock = MagicMock(return_value=True)
                with patch.object(mount, 'mount', mock):
                    self.assertTrue(mount.remount('name', 'device'))

        with patch.dict(mount.__grains__, {'os': 'Linux'}):
            mock = MagicMock(return_value=[])
            with patch.object(mount, 'active', mock):
                mock = MagicMock(return_value=True)
                with patch.object(mount, 'mount', mock):
                    self.assertTrue(mount.remount('name', 'device'))
Пример #4
0
    def test_remount_already_mounted_with_fstype(self):
        """
        Attempt to remount a device already mounted that do not provides
        fstype
        """
        with patch.dict(mount.__grains__, {"os": "MacOS"}):
            mock = MagicMock(return_value=["name"])
            with patch.object(mount, "active", mock):
                mock = MagicMock(return_value={"retcode": 0})
                with patch.dict(mount.__salt__, {"cmd.run_all": mock}):
                    self.assertTrue(
                        mount.remount("name", "device", fstype="type"))
                    mock.assert_called_with(
                        "mount -u -o noowners -t type device name ",
                        python_shell=False,
                        runas=None,
                    )

        with patch.dict(mount.__grains__, {"os": "AIX"}):
            mock = MagicMock(return_value=["name"])
            with patch.object(mount, "active", mock):
                mock = MagicMock(return_value={"retcode": 0})
                with patch.dict(mount.__salt__, {"cmd.run_all": mock}):
                    self.assertTrue(
                        mount.remount("name", "device", fstype="type"))
                    mock.assert_called_with(
                        "mount -o remount -v type device name ",
                        python_shell=False,
                        runas=None,
                    )

        with patch.dict(mount.__grains__, {"os": "Linux"}):
            mock = MagicMock(return_value=["name"])
            with patch.object(mount, "active", mock):
                mock = MagicMock(return_value={"retcode": 0})
                with patch.dict(mount.__salt__, {"cmd.run_all": mock}):
                    self.assertTrue(
                        mount.remount("name", "device", fstype="type"))
                    mock.assert_called_with(
                        "mount -o defaults,remount -t type device name ",
                        python_shell=False,
                        runas=None,
                    )
Пример #5
0
 def test_remount(self):
     '''
     Attempt to remount a device, if the device is not already mounted, mount
     is called
     '''
     with patch.dict(mount.__grains__, {'os': 'MacOS'}):
         mock = MagicMock(return_value=[])
         with patch.object(mount, 'active', mock):
             mock = MagicMock(return_value=True)
             with patch.object(mount, 'mount', mock):
                 self.assertTrue(mount.remount('name', 'device'))
Пример #6
0
 def test_remount(self):
     """
     Attempt to remount a device, if the device is not already mounted, mount
     is called
     """
     with patch.dict(mount.__grains__, {"os": "MacOS"}):
         mock = MagicMock(return_value=[])
         with patch.object(mount, "active", mock):
             mock = MagicMock(return_value=True)
             with patch.object(mount, "mount", mock):
                 self.assertTrue(mount.remount("name", "device"))
Пример #7
0
    def test_remount_non_mounted(self):
        '''
        Attempt to remount a device, if the device is not already mounted, mount
        is called
        """
        with patch.dict(mount.__grains__, {"os": "MacOS"}):
            mock = MagicMock(return_value=[])
            with patch.object(mount, "active", mock):
                mock = MagicMock(return_value=True)
                with patch.object(mount, "mount", mock):
                    self.assertTrue(mount.remount("name", "device"))

        with patch.dict(mount.__grains__, {"os": "AIX"}):
            mock = MagicMock(return_value=[])
            with patch.object(mount, "active", mock):
                mock = MagicMock(return_value=True)
                with patch.object(mount, "mount", mock):
                    self.assertTrue(mount.remount("name", "device"))

        with patch.dict(mount.__grains__, {"os": "Linux"}):
            mock = MagicMock(return_value=[])
            with patch.object(mount, "active", mock):
                mock = MagicMock(return_value=True)
                with patch.object(mount, "mount", mock):
                    self.assertTrue(mount.remount("name", "device"))

    def test_remount_already_mounted_no_fstype(self):
        """
        Attempt to remount a device already mounted that do not provides
        fstype
        """
        with patch.dict(mount.__grains__, {"os": "MacOS"}):
            mock = MagicMock(return_value=["name"])
            with patch.object(mount, "active", mock):
                mock = MagicMock(return_value={"retcode": 0})
                with patch.dict(mount.__salt__, {"cmd.run_all": mock}):
                    self.assertTrue(mount.remount("name", "device"))
                    mock.assert_called_with(
                        "mount -u -o noowners device name ",
                        python_shell=False,
                        runas=None,
                    )

        with patch.dict(mount.__grains__, {"os": "AIX"}):
            mock = MagicMock(return_value=["name"])
            with patch.object(mount, "active", mock):
                mock = MagicMock(return_value={"retcode": 0})
                with patch.dict(mount.__salt__, {"cmd.run_all": mock}):
                    self.assertTrue(mount.remount("name", "device"))
                    mock.assert_called_with(
                        "mount -o remount device name ", python_shell=False, runas=None
                    )

        with patch.dict(mount.__grains__, {"os": "Linux"}):
            mock = MagicMock(return_value=["name"])
            with patch.object(mount, "active", mock):
                mock = MagicMock(return_value={"retcode": 0})
                with patch.dict(mount.__salt__, {"cmd.run_all": mock}):
                    self.assertTrue(mount.remount("name", "device"))
                    mock.assert_called_with(
                        "mount -o defaults,remount device name ",
                        python_shell=False,
                        runas=None,
                    )

    def test_remount_already_mounted_with_fstype(self):
        """
        Attempt to remount a device already mounted that do not provides
        fstype
        """
        with patch.dict(mount.__grains__, {"os": "MacOS"}):
            mock = MagicMock(return_value=["name"])
            with patch.object(mount, "active", mock):
                mock = MagicMock(return_value={"retcode": 0})
                with patch.dict(mount.__salt__, {"cmd.run_all": mock}):
                    self.assertTrue(mount.remount("name", "device", fstype="type"))
                    mock.assert_called_with(
                        "mount -u -o noowners -t type device name ",
                        python_shell=False,
                        runas=None,
                    )

        with patch.dict(mount.__grains__, {"os": "AIX"}):
            mock = MagicMock(return_value=["name"])
            with patch.object(mount, "active", mock):
                mock = MagicMock(return_value={"retcode": 0})
                with patch.dict(mount.__salt__, {"cmd.run_all": mock}):
                    self.assertTrue(mount.remount("name", "device", fstype="type"))
                    mock.assert_called_with(
                        "mount -o remount -v type device name ",
                        python_shell=False,
                        runas=None,
                    )

        with patch.dict(mount.__grains__, {"os": "Linux"}):
            mock = MagicMock(return_value=["name"])
            with patch.object(mount, "active", mock):
                mock = MagicMock(return_value={"retcode": 0})
                with patch.dict(mount.__salt__, {"cmd.run_all": mock}):
                    self.assertTrue(mount.remount("name", "device", fstype="type"))
                    mock.assert_called_with(
                        "mount -o defaults,remount -t type device name ",
                        python_shell=False,
                        runas=None,
                    )

        with patch.dict(mount.__grains__, {'os': 'Linux'}):
            mock = MagicMock(return_value=[])
            with patch.object(mount, 'active', mock):
                mock = MagicMock(return_value=True)
                with patch.object(mount, 'mount', mock):
                    self.assertTrue(mount.remount('name', 'device'))

    def test_remount_already_mounted_no_fstype(self):
        '''
        Attempt to remount a device already mounted that do not provides
        fstype
        '''
        with patch.dict(mount.__grains__, {'os': 'MacOS'}):
            mock = MagicMock(return_value=['name'])
            with patch.object(mount, 'active', mock):
                mock = MagicMock(return_value={'retcode': 0})
                with patch.dict(mount.__salt__, {'cmd.run_all': mock}):
                    self.assertTrue(mount.remount('name', 'device'))
                    mock.assert_called_with('mount -u -o noowners device name ',
                                            python_shell=False, runas=None)

        with patch.dict(mount.__grains__, {'os': 'AIX'}):
            mock = MagicMock(return_value=['name'])
            with patch.object(mount, 'active', mock):
                mock = MagicMock(return_value={'retcode': 0})
                with patch.dict(mount.__salt__, {'cmd.run_all': mock}):
                    self.assertTrue(mount.remount('name', 'device'))
                    mock.assert_called_with('mount -o remount device name ',
                                            python_shell=False, runas=None)

        with patch.dict(mount.__grains__, {'os': 'Linux'}):
            mock = MagicMock(return_value=['name'])
            with patch.object(mount, 'active', mock):
                mock = MagicMock(return_value={'retcode': 0})
                with patch.dict(mount.__salt__, {'cmd.run_all': mock}):
                    self.assertTrue(mount.remount('name', 'device'))
                    mock.assert_called_with('mount -o defaults,remount device name ',
                                            python_shell=False, runas=None)

    def test_remount_already_mounted_with_fstype(self):
        '''
        Attempt to remount a device already mounted that do not provides
        fstype
        '''
        with patch.dict(mount.__grains__, {'os': 'MacOS'}):
            mock = MagicMock(return_value=['name'])
            with patch.object(mount, 'active', mock):
                mock = MagicMock(return_value={'retcode': 0})
                with patch.dict(mount.__salt__, {'cmd.run_all': mock}):
                    self.assertTrue(mount.remount('name', 'device', fstype='type'))
                    mock.assert_called_with('mount -u -o noowners -t type device name ',
                                            python_shell=False, runas=None)

        with patch.dict(mount.__grains__, {'os': 'AIX'}):
            mock = MagicMock(return_value=['name'])
            with patch.object(mount, 'active', mock):
                mock = MagicMock(return_value={'retcode': 0})
                with patch.dict(mount.__salt__, {'cmd.run_all': mock}):
                    self.assertTrue(mount.remount('name', 'device', fstype='type'))
                    mock.assert_called_with('mount -o remount -v type device name ',
                                            python_shell=False, runas=None)

        with patch.dict(mount.__grains__, {'os': 'Linux'}):
            mock = MagicMock(return_value=['name'])
            with patch.object(mount, 'active', mock):
                mock = MagicMock(return_value={'retcode': 0})
                with patch.dict(mount.__salt__, {'cmd.run_all': mock}):
                    self.assertTrue(mount.remount('name', 'device', fstype='type'))
                    mock.assert_called_with('mount -o defaults,remount -t type device name ',
                                            python_shell=False, runas=None)