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()