server/hosts/bootloader_unittest.py

#!/usr/bin/python

import unittest, os
import common

from autotest_lib.client.common_lib.test_utils import mock
from autotest_lib.client.common_lib import error, utils as common_utils
from autotest_lib.server import utils
from autotest_lib.server.hosts import bootloader, ssh_host


class test_bootloader_install(unittest.TestCase):
    def setUp(self):
        self.god = mock.mock_god()

        # mock out get_server_dir
        self.god.stub_function(utils, "get_server_dir")


    def tearDown(self):
        self.god.unstub_all()


    def create_mock_sshhost(self):
        # useful for building disposable SSHHost mocks
        return self.god.create_mock_class(ssh_host.SSHHost, "SSHHost")


    def create_install_boottool_mock(self, loader, dst_dir):
        mock_install_boottool = \
                self.god.create_mock_function("install_boottool")
        def install_boottool():
            loader._boottool_path = dst_dir
            mock_install_boottool()
        loader.install_boottool = install_boottool
        return mock_install_boottool


    def test_install_fails_without_host(self):
        host = self.create_mock_sshhost()
        loader = bootloader.Bootloader(host)
        del host
        self.assertRaises(error.AutoservError, loader.install_boottool)


    def test_installs_to_tmpdir(self):
        TMPDIR = "/unittest/tmp"
        SERVERDIR = "/unittest/server"
        BOOTTOOL_SRC = os.path.join(SERVERDIR, bootloader.BOOTTOOL_SRC)
        BOOTTOOL_SRC = os.path.abspath(BOOTTOOL_SRC)
        BOOTTOOL_DST = os.path.join(TMPDIR, "boottool")
        # set up the recording
        host = self.create_mock_sshhost()
        host.get_tmp_dir.expect_call().and_return(TMPDIR)
        utils.get_server_dir.expect_call().and_return(SERVERDIR)
        host.send_file.expect_call(BOOTTOOL_SRC, TMPDIR)
        # run the test
        loader = bootloader.Bootloader(host)
        loader.install_boottool()
        # assert the playback is correct
        self.god.check_playback()
        # assert the final dest is correct
        self.assertEquals(loader.boottool_path, BOOTTOOL_DST)


    def test_get_path_automatically_installs(self):
        BOOTTOOL_DST = "/unittest/tmp/boottool"
        host = self.create_mock_sshhost()
        loader = bootloader.Bootloader(host)
        # mock out loader.install_boottool
        mock_install = \
                self.create_install_boottool_mock(loader, BOOTTOOL_DST)
        # set up the recording
        mock_install.expect_call()
        # run the test
        self.assertEquals(loader.boottool_path, BOOTTOOL_DST)
        self.god.check_playback()


    def test_install_is_only_called_once(self):
        BOOTTOOL_DST = "/unittest/tmp/boottool"
        host = self.create_mock_sshhost()
        loader = bootloader.Bootloader(host)
        # mock out loader.install_boottool
        mock_install = \
                self.create_install_boottool_mock(loader, BOOTTOOL_DST)
        # set up the recording
        mock_install.expect_call()
        # run the test
        self.assertEquals(loader.boottool_path, BOOTTOOL_DST)
        self.god.check_playback()
        self.assertEquals(loader.boottool_path, BOOTTOOL_DST)
        self.god.check_playback()


class test_bootloader_methods(unittest.TestCase):
    def setUp(self):
        self.god = mock.mock_god()
        self.host = self.god.create_mock_class(ssh_host.SSHHost,
                                               "SSHHost")
        # creates a bootloader with _run_boottool mocked out
        self.loader = bootloader.Bootloader(self.host)
        self.god.stub_function(self.loader, "_run_boottool")


    def tearDown(self):
        self.god.unstub_all()


    def expect_run_boottool(self, arg, result):
        result = common_utils.CmdResult(stdout=result, exit_status=0)
        self.loader._run_boottool.expect_call(arg).and_return(result)


    def test_get_type(self):
        # set up the recording
        self.expect_run_boottool("--bootloader-probe", "lilo\n")
        # run the test
        self.assertEquals(self.loader.get_type(), "lilo")
        self.god.check_playback()


    def test_get_arch(self):
        # set up the recording
        self.expect_run_boottool("--arch-probe", "x86_64\n")
        # run the test
        self.assertEquals(self.loader.get_architecture(), "x86_64")
        self.god.check_playback()


    def test_get_default(self):
        # set up the recording
        self.expect_run_boottool("--default", "0\n")
        # run the test
        self.assertEquals(self.loader.get_default(), "0")
        self.god.check_playback()


    def test_get_titles(self):
        # set up the recording
        self.expect_run_boottool(mock.regex_comparator(
            r"^--info all \|"), "title #1\ntitle #2\n")
        # run the test
        self.assertEquals(self.loader.get_titles(),
                          ["title #1", "title #2"])
        self.god.check_playback()


    def test_get_info_single_result(self):
        RESULT = (
        "index\t: 5\n"
        "args\t: ro single\n"
        "boot\t: (hd0,0)\n"
        "initrd\t: /boot/initrd.img-2.6.15-23-386\n"
        "kernel\t: /boot/vmlinuz-2.6.15-23-386\n"
        "root\t: UUID=07D7-0714\n"
        "savedefault\t:   \n"
        "title\t: Distro, kernel 2.6.15-23-386\n"
        )
        # set up the recording
        self.expect_run_boottool("--info=5", RESULT)
        # run the test
        info = self.loader.get_info(5)
        self.god.check_playback()
        expected_info = {"index": "5", "args": "ro single",
                         "boot": "(hd0,0)",
                         "initrd": "/boot/initrd.img-2.6.15-23-386",
                         "kernel": "/boot/vmlinuz-2.6.15-23-386",
                         "root": "UUID=07D7-0714", "savedefault": "",
                         "title": "Distro, kernel 2.6.15-23-386"}
        self.assertEquals(expected_info, info)


    def test_get_info_missing_result(self):
        # set up the recording
        self.expect_run_boottool("--info=4", "")
        # run the test
        info = self.loader.get_info(4)
        self.god.check_playback()
        self.assertEquals({}, info)


    def test_get_info_multiple_results(self):
        RESULT = (
        "index\t: 5\n"
        "args\t: ro single\n"
        "boot\t: (hd0,0)\n"
        "initrd\t: /boot/initrd.img-2.6.15-23-386\n"
        "kernel\t: /boot/vmlinuz-2.6.15-23-386\n"
        "root\t: UUID=07D7-0714\n"
        "savedefault\t:   \n"
        "title\t: Distro, kernel 2.6.15-23-386\n"
        "\n"
        "index\t: 7\n"
        "args\t: ro single\n"
        "boot\t: (hd0,0)\n"
        "initrd\t: /boot/initrd.img-2.6.15-23-686\n"
        "kernel\t: /boot/vmlinuz-2.6.15-23-686\n"
        "root\t: UUID=07D7-0714\n"
        "savedefault\t:   \n"
        "title\t: Distro, kernel 2.6.15-23-686\n"
        )
        # set up the recording
        self.expect_run_boottool("--info=all", RESULT)
        # run the test
        info = self.loader.get_all_info()
        self.god.check_playback()
        expected_info = [{"index": "5", "args": "ro single",
                          "boot": "(hd0,0)",
                          "initrd": "/boot/initrd.img-2.6.15-23-386",
                          "kernel": "/boot/vmlinuz-2.6.15-23-386",
                          "root": "UUID=07D7-0714", "savedefault": "",
                          "title": "Distro, kernel 2.6.15-23-386"},
                         {"index": "7", "args": "ro single",
                          "boot": "(hd0,0)",
                          "initrd": "/boot/initrd.img-2.6.15-23-686",
                          "kernel": "/boot/vmlinuz-2.6.15-23-686",
                          "root": "UUID=07D7-0714", "savedefault": "",
                          "title": "Distro, kernel 2.6.15-23-686"}]
        self.assertEquals(expected_info, info)


    def test_set_default(self):
        # set up the recording
        self.loader._run_boottool.expect_call("--set-default=41")
        # run the test
        self.loader.set_default(41)
        self.god.check_playback()


    def test_add_args(self):
        # set up the recording
        self.loader._run_boottool.expect_call(
            "--update-kernel=10 --args=\"some kernel args\"")
        # run the test
        self.loader.add_args(10, "some kernel args")
        self.god.check_playback()


    def test_remove_args(self):
        # set up the recording
        self.loader._run_boottool.expect_call(
            "--update-kernel=12 --remove-args=\"some kernel args\"")
        # run the test
        self.loader.remove_args(12, "some kernel args")
        self.god.check_playback()


    def test_add_kernel_basic(self):
        self.loader.get_titles = self.god.create_mock_function(
            "get_titles")
        # set up the recording
        self.loader.get_titles.expect_call().and_return(["notmylabel"])
        self.loader._run_boottool.expect_call(
            "--add-kernel \"/unittest/kernels/vmlinuz\" "
            "--title \"mylabel\" --make-default")
        # run the test
        self.loader.add_kernel("/unittest/kernels/vmlinuz",
                               "mylabel")
        self.god.check_playback()


    def test_add_kernel_adds_root(self):
        self.loader.get_titles = self.god.create_mock_function(
            "get_titles")
        # set up the recording
        self.loader.get_titles.expect_call().and_return(["notmylabel"])
        self.loader._run_boottool.expect_call(
            "--add-kernel \"/unittest/kernels/vmlinuz\" "
            "--title \"mylabel\" --root \"/unittest/root\" "
            "--make-default")
        # run the test
        self.loader.add_kernel("/unittest/kernels/vmlinuz",
                               "mylabel", root="/unittest/root")
        self.god.check_playback()


    def test_add_kernel_adds_args(self):
        self.loader.get_titles = self.god.create_mock_function(
            "get_titles")
        # set up the recording
        self.loader.get_titles.expect_call().and_return(["notmylabel"])
        self.loader._run_boottool.expect_call(
            "--add-kernel \"/unittest/kernels/vmlinuz\" "
            "--title \"mylabel\" --args \"my kernel args\" "
            "--make-default")
        # run the test
        self.loader.add_kernel("/unittest/kernels/vmlinuz",
                               "mylabel", args="my kernel args")
        self.god.check_playback()


    def test_add_kernel_adds_initrd(self):
        self.loader.get_titles = self.god.create_mock_function(
            "get_titles")
        # set up the recording
        self.loader.get_titles.expect_call().and_return(["notmylabel"])
        self.loader._run_boottool.expect_call(
            "--add-kernel \"/unittest/kernels/vmlinuz\" "
            "--title \"mylabel\" --initrd \"/unittest/initrd\" "
            "--make-default")
        # run the test
        self.loader.add_kernel("/unittest/kernels/vmlinuz",
                               "mylabel", initrd="/unittest/initrd")
        self.god.check_playback()


    def test_add_kernel_disables_make_default(self):
        self.loader.get_titles = self.god.create_mock_function(
            "get_titles")
        # set up the recording
        self.loader.get_titles.expect_call().and_return(["notmylabel"])
        self.loader._run_boottool.expect_call(
            "--add-kernel \"/unittest/kernels/vmlinuz\" "
            "--title \"mylabel\"")
        # run the test
        self.loader.add_kernel("/unittest/kernels/vmlinuz",
                               "mylabel", default=False)
        self.god.check_playback()


    def test_add_kernel_removes_old(self):
        self.loader.get_titles = self.god.create_mock_function(
            "get_titles")
        # set up the recording
        self.loader.get_titles.expect_call().and_return(["mylabel"])
        self.loader._run_boottool.expect_call(
            "--remove-kernel \"mylabel\"")
        self.loader._run_boottool.expect_call(
            "--add-kernel \"/unittest/kernels/vmlinuz\" "
            "--title \"mylabel\" --make-default")
        # run the test
        self.loader.add_kernel("/unittest/kernels/vmlinuz",
                               "mylabel")
        self.god.check_playback()


    def test_remove_kernel(self):
        # set up the recording
        self.loader._run_boottool.expect_call("--remove-kernel=14")
        # run the test
        self.loader.remove_kernel(14)
        self.god.check_playback()


    def test_boot_once(self):
        # set up the recording
        self.loader._run_boottool.expect_call(
            "--boot-once --title=autotest")
        # run the test
        self.loader.boot_once("autotest")
        self.god.check_playback()


if __name__ == "__main__":
    unittest.main()