# This file is part of cloud-init. See LICENSE file for license information.

import pytest

from unittest import mock

from logging import Logger

from cloudinit.subp import ProcessExecutionError

from cloudinit.config.cc_grub_dpkg import fetch_idevs, handle

class TestFetchIdevs:

    """Tests cc_grub_dpkg.fetch_idevs()"""

    # Note: udevadm info returns devices in a large single line string

    @pytest.mark.parametrize(

        "grub_output,path_exists,expected_log_call,udevadm_output"

        ",expected_idevs",

        [

            # Inside a container, grub not installed

            (

                ProcessExecutionError(reason=FileNotFoundError()),

                False,

                mock.call("'grub-probe' not found in $PATH"),

                '',

                '',

            ),

            # Inside a container, grub installed

            (

                ProcessExecutionError(stderr="failed to get canonical path"),

                False,

                mock.call("grub-probe 'failed to get canonical path'"),

                '',

                '',

            ),

            # KVM Instance

            (

                ['/dev/vda'],

                True,

                None,

                (

                    '/dev/disk/by-path/pci-0000:00:00.0 ',

                    '/dev/disk/by-path/virtio-pci-0000:00:00.0 '

                ),

                '/dev/vda',

            ),

            # Xen Instance

            (

                ['/dev/xvda'],

                True,

                None,

                '',

                '/dev/xvda',

            ),

            # NVMe Hardware Instance

            (

                ['/dev/nvme1n1'],

                True,

                None,

                (

                    '/dev/disk/by-id/nvme-Company_hash000 ',

                    '/dev/disk/by-id/nvme-nvme.000-000-000-000-000 ',

                    '/dev/disk/by-path/pci-0000:00:00.0-nvme-0 '

                ),

                '/dev/disk/by-id/nvme-Company_hash000',

            ),

            # SCSI Hardware Instance

            (

                ['/dev/sda'],

                True,

                None,

                (

                    '/dev/disk/by-id/company-user-1 ',

                    '/dev/disk/by-id/scsi-0Company_user-1 ',

                    '/dev/disk/by-path/pci-0000:00:00.0-scsi-0:0:0:0 '

                ),

                '/dev/disk/by-id/company-user-1',

            ),

        ],

    )

    @mock.patch("cloudinit.config.cc_grub_dpkg.util.logexc")

    @mock.patch("cloudinit.config.cc_grub_dpkg.os.path.exists")

    @mock.patch("cloudinit.config.cc_grub_dpkg.subp.subp")

    def test_fetch_idevs(self, m_subp, m_exists, m_logexc, grub_output,

                         path_exists, expected_log_call, udevadm_output,

                         expected_idevs):

        """Tests outputs from grub-probe and udevadm info against grub-dpkg"""

        m_subp.side_effect = [

            grub_output,

            ["".join(udevadm_output)]

        ]

        m_exists.return_value = path_exists

        log = mock.Mock(spec=Logger)

        idevs = fetch_idevs(log)

        assert expected_idevs == idevs

        if expected_log_call is not None:

            assert expected_log_call in log.debug.call_args_list

class TestHandle:

    """Tests cc_grub_dpkg.handle()"""

    @pytest.mark.parametrize(

        "cfg_idevs,cfg_idevs_empty,fetch_idevs_output,expected_log_output",

        [

            (

                # No configuration

                None,

                None,

                '/dev/disk/by-id/nvme-Company_hash000',

                (

                    "Setting grub debconf-set-selections with ",

                    "'/dev/disk/by-id/nvme-Company_hash000','false'"

                ),

            ),

            (

                # idevs set, idevs_empty unset

                '/dev/sda',

                None,

                '/dev/sda',

                (

                    "Setting grub debconf-set-selections with ",

                    "'/dev/sda','false'"

                ),

            ),

            (

                # idevs unset, idevs_empty set

                None,

                'true',

                '/dev/xvda',

                (

                    "Setting grub debconf-set-selections with ",

                    "'/dev/xvda','true'"

                ),

            ),

            (

                # idevs set, idevs_empty set

                '/dev/vda',

                'false',

                '/dev/disk/by-id/company-user-1',

                (

                    "Setting grub debconf-set-selections with ",

                    "'/dev/vda','false'"

                ),

            ),

            (

                # idevs set, idevs_empty set

                # Respect what the user defines, even if its logically wrong

                '/dev/nvme0n1',

                'true',

                '',

                (

                    "Setting grub debconf-set-selections with ",

                    "'/dev/nvme0n1','true'"

                ),

            )

        ],

    )

    @mock.patch("cloudinit.config.cc_grub_dpkg.fetch_idevs")

    @mock.patch("cloudinit.config.cc_grub_dpkg.util.get_cfg_option_str")

    @mock.patch("cloudinit.config.cc_grub_dpkg.util.logexc")

    @mock.patch("cloudinit.config.cc_grub_dpkg.subp.subp")

    def test_handle(self, m_subp, m_logexc, m_get_cfg_str, m_fetch_idevs,

                    cfg_idevs, cfg_idevs_empty, fetch_idevs_output,

                    expected_log_output):

        """Test setting of correct debconf database entries"""

        m_get_cfg_str.side_effect = [

            cfg_idevs,

            cfg_idevs_empty

        ]

        m_fetch_idevs.return_value = fetch_idevs_output

        log = mock.Mock(spec=Logger)

        handle(mock.Mock(), mock.Mock(), mock.Mock(), log, mock.Mock())

        log.debug.assert_called_with("".join(expected_log_output))

# vi: ts=4 expandtab