Exemplo n.º 1
0
    def test_swaps(self):
        '''
        Return a dict containing information on active swap
        '''

        file_data = '\n'.join(['Filename Type Size Used Priority',
                               '/dev/sda1 partition 31249404 4100 -1'])
        with patch.dict(mount.__grains__, {'os': '', 'kernel': ''}):
            with patch('salt.utils.fopen',
                       mock_open(read_data=file_data),
                       create=True) as m:
                m.return_value.__iter__.return_value = file_data.splitlines()

                self.assertDictEqual(mount.swaps(), {'/dev/sda1':
                                                     {'priority': '-1',
                                                      'size': '31249404',
                                                      'type': 'partition',
                                                      'used': '4100'}})

        file_data = '\n'.join(['Device Size Used Unknown Unknown Priority',
                               '/dev/sda1 31249404 4100 unknown unknown -1'])
        mock = MagicMock(return_value=file_data)
        with patch.dict(mount.__grains__, {'os': 'OpenBSD', 'kernel': 'OpenBSD'}):
            with patch.dict(mount.__salt__, {'cmd.run_stdout': mock}):
                self.assertDictEqual(mount.swaps(), {'/dev/sda1':
                                                     {'priority': '-1',
                                                      'size': '31249404',
                                                      'type': 'partition',
                                                      'used': '4100'}})
Exemplo n.º 2
0
    def test_swaps(self):
        '''
        Return a dict containing information on active swap
        '''

        file_data = textwrap.dedent('''\
            Filename Type Size Used Priority
            /dev/sda1 partition 31249404 4100 -1
            ''')
        with patch.dict(mount.__grains__, {'os': '', 'kernel': ''}):
            with patch('salt.utils.files.fopen', mock_open(read_data=file_data)):
                swaps = mount.swaps()
                assert swaps == {
                    '/dev/sda1': {
                        'priority': '-1',
                        'size': '31249404',
                        'type': 'partition',
                        'used': '4100'}
                }, swaps

        file_data = textwrap.dedent('''\
            Device Size Used Unknown Unknown Priority
            /dev/sda1 31249404 4100 unknown unknown -1
            ''')
        mock = MagicMock(return_value=file_data)
        with patch.dict(mount.__grains__, {'os': 'OpenBSD', 'kernel': 'OpenBSD'}), \
                patch.dict(mount.__salt__, {'cmd.run_stdout': mock}):
            swaps = mount.swaps()
            assert swaps == {
                '/dev/sda1': {
                    'priority': '-1',
                    'size': '31249404',
                    'type': 'partition',
                    'used': '4100'}
            }, swaps
Exemplo n.º 3
0
    def test_swaps(self):
        '''
        Return a dict containing information on active swap
        '''

        file_data = '\n'.join(['Filename Type Size Used Priority',
                               '/dev/sda1 partition 31249404 4100 -1'])
        with patch.dict(mount.__grains__, {'os': ''}):
            with patch('salt.utils.fopen',
                       mock_open(read_data=file_data),
                       create=True) as m:
                m.return_value.__iter__.return_value = file_data.splitlines()

                self.assertDictEqual(mount.swaps(), {'/dev/sda1':
                                                     {'priority': '-1',
                                                      'size': '31249404',
                                                      'type': 'partition',
                                                      'used': '4100'}})

        file_data = '\n'.join(['Device Size Used Unknown Unknown Priority',
                               '/dev/sda1 31249404 4100 unknown unknown -1'])
        mock = MagicMock(return_value=file_data)
        with patch.dict(mount.__grains__, {'os': 'OpenBSD'}):
            with patch.dict(mount.__salt__, {'cmd.run_stdout': mock}):
                self.assertDictEqual(mount.swaps(), {'/dev/sda1':
                                                     {'priority': '-1',
                                                      'size': '31249404',
                                                      'type': 'partition',
                                                      'used': '4100'}})
Exemplo n.º 4
0
    def test_swaps(self):
        """
        Return a dict containing information on active swap
        """

        file_data = "\n".join(["Filename Type Size Used Priority", "/dev/sda1 partition 31249404 4100 -1"])
        with patch.dict(mount.__grains__, {"os": "", "kernel": ""}):
            with patch("salt.utils.fopen", mock_open(read_data=file_data), create=True) as m:
                m.return_value.__iter__.return_value = file_data.splitlines()

                self.assertDictEqual(
                    mount.swaps(),
                    {"/dev/sda1": {"priority": "-1", "size": "31249404", "type": "partition", "used": "4100"}},
                )

        file_data = "\n".join(
            ["Device Size Used Unknown Unknown Priority", "/dev/sda1 31249404 4100 unknown unknown -1"]
        )
        mock = MagicMock(return_value=file_data)
        with patch.dict(mount.__grains__, {"os": "OpenBSD", "kernel": "OpenBSD"}):
            with patch.dict(mount.__salt__, {"cmd.run_stdout": mock}):
                self.assertDictEqual(
                    mount.swaps(),
                    {"/dev/sda1": {"priority": "-1", "size": "31249404", "type": "partition", "used": "4100"}},
                )
Exemplo n.º 5
0
    def test_swaps(self):
        """
        Return a dict containing information on active swap
        """
        file_data = textwrap.dedent("""\
            Filename Type Size Used Priority
            /dev/sda1 partition 31249404 4100 -1
            """)
        with patch.dict(mount.__grains__, {"os": "", "kernel": ""}):
            with patch("salt.utils.files.fopen",
                       mock_open(read_data=file_data)):
                swaps = mount.swaps()
                assert swaps == {
                    "/dev/sda1": {
                        "priority": "-1",
                        "size": "31249404",
                        "type": "partition",
                        "used": "4100",
                    }
                }, swaps

        file_data = textwrap.dedent("""\
            Device Size Used Unknown Unknown Priority
            /dev/sda1 31249404 4100 unknown unknown -1
            """)
        mock = MagicMock(return_value=file_data)
        with patch.dict(mount.__grains__, {
                "os": "OpenBSD",
                "kernel": "OpenBSD"
        }), patch.dict(mount.__salt__, {"cmd.run_stdout": mock}):
            swaps = mount.swaps()
            assert swaps == {
                "/dev/sda1": {
                    "priority": "-1",
                    "size": "31249404",
                    "type": "partition",
                    "used": "4100",
                }
            }, swaps

        file_data = textwrap.dedent("""\
            device              maj,min        total       free
            /dev/hd6              10,  2     11776MB     11765MB
            """)
        mock = MagicMock(return_value=file_data)
        with patch.dict(mount.__grains__, {
                "os": "AIX",
                "kernel": "AIX"
        }), patch.dict(mount.__salt__, {"cmd.run_stdout": mock}):
            swaps = mount.swaps()
            assert swaps == {
                "/dev/hd6": {
                    "priority": "-",
                    "size": 12058624,
                    "type": "device",
                    "used": 11264,
                }
            }, swaps