Python PartitionerDasd Examples

Example #1

File: partitioner_dasd_test.py Project: AdamMajer/kiwi-ng

class TestPartitionerDasd(object):
    @patch('kiwi.partitioner.dasd.Command.run')
    @patch('kiwi.partitioner.dasd.NamedTemporaryFile')
    @patch_open
    def setup(self, mock_open, mock_temp, mock_command):
        self.tempfile = mock.Mock()
        self.tempfile.name = 'tempfile'
        self.context_manager_mock = mock.Mock()
        self.file_mock = mock.Mock()
        self.enter_mock = mock.Mock()
        self.exit_mock = mock.Mock()
        self.enter_mock.return_value = self.file_mock
        setattr(self.context_manager_mock, '__enter__', self.enter_mock)
        setattr(self.context_manager_mock, '__exit__', self.exit_mock)

        mock_temp.return_value = self.tempfile
        mock_open.return_value = self.context_manager_mock

        disk_provider = mock.Mock()
        disk_provider.get_device = mock.Mock(
            return_value='/dev/loop0'
        )

        self.partitioner = PartitionerDasd(disk_provider)

    @patch('kiwi.partitioner.dasd.Command.run')
    @patch('kiwi.partitioner.dasd.NamedTemporaryFile')
    @patch_open
    @patch('kiwi.logger.log.debug')
    def test_create(self, mock_debug, mock_open, mock_temp, mock_command):
        mock_command.side_effect = Exception
        mock_temp.return_value = self.tempfile
        mock_open.return_value = self.context_manager_mock

        self.partitioner.create('name', 100, 't.linux', ['f.active'])

        self.file_mock.write.assert_called_once_with(
            'n\np\n\n+100M\nw\nq\n'
        )
        mock_command.assert_called_once_with(
            ['bash', '-c', 'cat tempfile | fdasd -f /dev/loop0']
        )
        assert mock_debug.called

    @patch('kiwi.partitioner.dasd.Command.run')
    @patch('kiwi.partitioner.dasd.NamedTemporaryFile')
    @patch_open
    def test_create_all_free(
        self, mock_open, mock_temp, mock_command
    ):
        mock_temp.return_value = self.tempfile
        mock_open.return_value = self.context_manager_mock

        self.partitioner.create('name', 'all_free', 't.linux')

        self.file_mock.write.assert_called_once_with(
            'n\np\n\n\nw\nq\n'
        )

Example #2

File: partitioner_dasd_test.py Project: jitendraky/kiwi

    def setup(self, mock_temp, mock_command):
        self.tempfile = mock.Mock()
        self.tempfile.name = 'tempfile'

        mock_temp.return_value = self.tempfile

        disk_provider = mock.Mock()
        disk_provider.get_device = mock.Mock(return_value='/dev/loop0')

        self.partitioner = PartitionerDasd(disk_provider)

Example #3

File: partitioner_dasd_test.py Project: ucytech/kiwi

class TestPartitionerDasd(object):
    @patch('kiwi.partitioner.dasd.Command.run')
    @patch('kiwi.partitioner.dasd.NamedTemporaryFile')
    @patch_open
    def setup(self, mock_open, mock_temp, mock_command):
        self.tempfile = mock.Mock()
        self.tempfile.name = 'tempfile'
        self.context_manager_mock = mock.Mock()
        self.file_mock = mock.Mock()
        self.enter_mock = mock.Mock()
        self.exit_mock = mock.Mock()
        self.enter_mock.return_value = self.file_mock
        setattr(self.context_manager_mock, '__enter__', self.enter_mock)
        setattr(self.context_manager_mock, '__exit__', self.exit_mock)

        mock_temp.return_value = self.tempfile
        mock_open.return_value = self.context_manager_mock

        disk_provider = mock.Mock()
        disk_provider.get_device = mock.Mock(return_value='/dev/loop0')

        self.partitioner = PartitionerDasd(disk_provider)

    @patch('kiwi.partitioner.dasd.Command.run')
    @patch('kiwi.partitioner.dasd.NamedTemporaryFile')
    @patch_open
    @patch('kiwi.logger.log.debug')
    def test_create(self, mock_debug, mock_open, mock_temp, mock_command):
        mock_command.side_effect = Exception
        mock_temp.return_value = self.tempfile
        mock_open.return_value = self.context_manager_mock

        self.partitioner.create('name', 100, 't.linux', ['f.active'])

        self.file_mock.write.assert_called_once_with('n\np\n\n+100M\nw\nq\n')
        mock_command.assert_called_once_with(
            ['bash', '-c', 'cat tempfile | fdasd -f /dev/loop0'])
        assert mock_debug.called

    @patch('kiwi.partitioner.dasd.Command.run')
    @patch('kiwi.partitioner.dasd.NamedTemporaryFile')
    @patch_open
    def test_create_all_free(self, mock_open, mock_temp, mock_command):
        mock_temp.return_value = self.tempfile
        mock_open.return_value = self.context_manager_mock

        self.partitioner.create('name', 'all_free', 't.linux')

        self.file_mock.write.assert_called_once_with('n\np\n\n\nw\nq\n')

Example #4

    def __new__(self, table_type, storage_provider):  # noqa: C901
        host_architecture = platform.machine()
        if host_architecture == 'x86_64':
            if table_type == 'gpt':
                return PartitionerGpt(storage_provider)
            elif table_type == 'msdos':
                return PartitionerMsDos(storage_provider)

        elif host_architecture == 'i686' or host_architecture == 'i586':
            if table_type == 'msdos':
                return PartitionerMsDos(storage_provider)

        elif 'ppc64' in host_architecture:
            if table_type == 'gpt':
                return PartitionerGpt(storage_provider)
            elif table_type == 'msdos':
                return PartitionerMsDos(storage_provider)

        elif 's390' in host_architecture:
            if table_type == 'dasd':
                return PartitionerDasd(storage_provider)
            elif table_type == 'msdos':
                return PartitionerMsDos(storage_provider)

        elif 'arm' in host_architecture or host_architecture == 'aarch64':
            if table_type == 'gpt':
                return PartitionerGpt(storage_provider)
            elif table_type == 'msdos':
                return PartitionerMsDos(storage_provider)

        raise KiwiPartitionerSetupError(
            'Support for partitioner on %s architecture not implemented' %
            host_architecture)

Example #5

File: partitioner_dasd_test.py Project: nadvornik/kiwi

    def setup(self, mock_open, mock_temp, mock_command):
        self.tempfile = mock.Mock()
        self.tempfile.name = 'tempfile'
        self.context_manager_mock = mock.Mock()
        self.file_mock = mock.Mock()
        self.enter_mock = mock.Mock()
        self.exit_mock = mock.Mock()
        self.enter_mock.return_value = self.file_mock
        setattr(self.context_manager_mock, '__enter__', self.enter_mock)
        setattr(self.context_manager_mock, '__exit__', self.exit_mock)

        mock_temp.return_value = self.tempfile
        mock_open.return_value = self.context_manager_mock

        disk_provider = mock.Mock()
        disk_provider.get_device = mock.Mock(return_value='/dev/loop0')

        self.partitioner = PartitionerDasd(disk_provider)

Example #6

class TestPartitionerDasd:
    @fixture(autouse=True)
    def inject_fixtures(self, caplog):
        self._caplog = caplog

    @patch('kiwi.partitioner.dasd.Command.run')
    @patch('kiwi.partitioner.dasd.Temporary.new_file')
    def setup(self, mock_temp, mock_command):
        self.tempfile = mock.Mock()
        self.tempfile.name = 'tempfile'

        mock_temp.return_value = self.tempfile

        disk_provider = mock.Mock()
        disk_provider.get_device = mock.Mock(
            return_value='/dev/loop0'
        )

        self.partitioner = PartitionerDasd(disk_provider)

    @patch('kiwi.partitioner.dasd.Command.run')
    @patch('kiwi.partitioner.dasd.Temporary.new_file')
    def setup_method(self, cls, mock_temp, mock_command):
        self.setup()

    @patch('kiwi.partitioner.dasd.Command.run')
    @patch('kiwi.partitioner.dasd.Temporary.new_file')
    def test_create(self, mock_temp, mock_command):
        mock_command.side_effect = Exception
        mock_temp.return_value = self.tempfile

        m_open = mock_open()
        with patch('builtins.open', m_open, create=True):
            with self._caplog.at_level(logging.DEBUG):
                self.partitioner.create('name', '100', 't.linux', ['f.active'])

        m_open.return_value.write.assert_called_once_with(
            'n\np\n\n+100M\nw\nq\n'
        )
        mock_command.assert_called_once_with(
            ['bash', '-c', 'cat tempfile | fdasd -f /dev/loop0']
        )

    @patch('kiwi.partitioner.dasd.Command.run')
    @patch('kiwi.partitioner.dasd.Temporary.new_file')
    def test_create_all_free(self, mock_temp, mock_command):
        mock_temp.return_value = self.tempfile

        m_open = mock_open()
        with patch('builtins.open', m_open, create=True):
            self.partitioner.create('name', 'all_free', 't.linux')

        m_open.return_value.write.assert_called_once_with(
            'n\np\n\n\nw\nq\n'
        )

    def test_resize_table(self):
        self.partitioner.resize_table()

Example #7

File: partitioner_dasd_test.py Project: AdamMajer/kiwi-ng

    def setup(self, mock_open, mock_temp, mock_command):
        self.tempfile = mock.Mock()
        self.tempfile.name = 'tempfile'
        self.context_manager_mock = mock.Mock()
        self.file_mock = mock.Mock()
        self.enter_mock = mock.Mock()
        self.exit_mock = mock.Mock()
        self.enter_mock.return_value = self.file_mock
        setattr(self.context_manager_mock, '__enter__', self.enter_mock)
        setattr(self.context_manager_mock, '__exit__', self.exit_mock)

        mock_temp.return_value = self.tempfile
        mock_open.return_value = self.context_manager_mock

        disk_provider = mock.Mock()
        disk_provider.get_device = mock.Mock(
            return_value='/dev/loop0'
        )

        self.partitioner = PartitionerDasd(disk_provider)

Example #8

    def __new__(self,
                table_type,
                storage_provider,
                start_sector=None):  # noqa: C901
        host_architecture = platform.machine()
        if host_architecture == 'x86_64':
            if table_type == 'gpt':
                return PartitionerGpt(storage_provider, start_sector)
            elif table_type == 'msdos':
                return PartitionerMsDos(storage_provider, start_sector)

        elif host_architecture == 'i686' or host_architecture == 'i586':
            if table_type == 'msdos':
                return PartitionerMsDos(storage_provider, start_sector)

        elif 'ppc64' in host_architecture:
            if table_type == 'gpt':
                return PartitionerGpt(storage_provider, start_sector)
            elif table_type == 'msdos':
                return PartitionerMsDos(storage_provider, start_sector)

        elif 's390' in host_architecture:
            if table_type == 'dasd':
                if start_sector:
                    log.warning('disk_start_sector value is ignored '
                                'for dasd partitions')
                return PartitionerDasd(storage_provider)
            elif table_type == 'msdos':
                return PartitionerMsDos(storage_provider, start_sector)

        elif 'arm' in host_architecture or host_architecture == 'aarch64':
            if table_type == 'gpt':
                return PartitionerGpt(storage_provider, start_sector)
            elif table_type == 'msdos':
                return PartitionerMsDos(storage_provider, start_sector)

        raise KiwiPartitionerSetupError(
            'Support for partitioner on %s architecture not implemented' %
            host_architecture)

Example #9

File: partitioner_dasd_test.py Project: jitendraky/kiwi

class TestPartitionerDasd:
    @patch('kiwi.partitioner.dasd.Command.run')
    @patch('kiwi.partitioner.dasd.NamedTemporaryFile')
    def setup(self, mock_temp, mock_command):
        self.tempfile = mock.Mock()
        self.tempfile.name = 'tempfile'

        mock_temp.return_value = self.tempfile

        disk_provider = mock.Mock()
        disk_provider.get_device = mock.Mock(return_value='/dev/loop0')

        self.partitioner = PartitionerDasd(disk_provider)

    @patch('kiwi.partitioner.dasd.Command.run')
    @patch('kiwi.partitioner.dasd.NamedTemporaryFile')
    @patch('kiwi.logger.log.debug')
    def test_create(self, mock_debug, mock_temp, mock_command):
        mock_command.side_effect = Exception
        mock_temp.return_value = self.tempfile

        m_open = mock_open()
        with patch('builtins.open', m_open, create=True):
            self.partitioner.create('name', 100, 't.linux', ['f.active'])

        m_open.return_value.write.assert_called_once_with(
            'n\np\n\n+100M\nw\nq\n')
        mock_command.assert_called_once_with(
            ['bash', '-c', 'cat tempfile | fdasd -f /dev/loop0'])
        assert mock_debug.called

    @patch('kiwi.partitioner.dasd.Command.run')
    @patch('kiwi.partitioner.dasd.NamedTemporaryFile')
    def test_create_all_free(self, mock_temp, mock_command):
        mock_temp.return_value = self.tempfile

        m_open = mock_open()
        with patch('builtins.open', m_open, create=True):
            self.partitioner.create('name', 'all_free', 't.linux')

        m_open.return_value.write.assert_called_once_with('n\np\n\n\nw\nq\n')

    def test_resize_table(self):
        self.partitioner.resize_table()