| #!/usr/bin/env python3 |
| # Copyright 2017 The ChromiumOS Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Unit tests for pack_firmware.py. |
| |
| This mocks out all tools so it can run fairly quickly. |
| """ |
| |
| import contextlib |
| import glob |
| import io |
| import os |
| import shutil |
| import struct |
| import sys |
| from unittest import mock |
| |
| import pack_firmware |
| import pack_firmware_utils |
| |
| from chromite.lib import cros_test_lib |
| from chromite.lib import osutils |
| from chromite.lib import partial_mock |
| from chromite.signing.lib import firmware_unittest |
| |
| |
| # We need to poke around in internal members of PackFirmware. |
| # pylint: disable=W0212 |
| |
| # Pre-set ID expected for test/image.bin. Note the 'R' in the first is a 'W' |
| # in the second. It is confusing but this is how the firmware images are |
| # currently created. |
| RO_FRID = "Google_Reef.9264.0.0_d2017_02_09_1240" |
| RW_FWID = "Google_Reef.9264.0.0_d2017_02_09_1250" |
| NO_TIMESTAMP_RO_FRID = "Google_Reef.9264.0.1" |
| EC_RO_FRID = "reef_v1.1.5857-77f6ed7" |
| EC_RW_FWID = "reef_v1.1.5858-77f6ed7" |
| EC_RO_FRID_NEW = "reef-9264.0.0" |
| |
| |
| # Expected output from 'futility dump_fmap -p' for main image. |
| FMAP_OUTPUT = """WP_RO 0 4194304 |
| SI_DESC 0 4096 |
| IFWI 4096 2093056 |
| RO_VPD 2097152 16384 |
| RO_SECTION 2113536 2080768 |
| FMAP 2113536 2048 |
| RO_FRID 2115584 64 |
| RO_FRID_PAD 2115648 1984 |
| COREBOOT 2117632 1552384 |
| GBB 3670016 262144 |
| RO_UNUSED 3932160 262144 |
| MISC_RW 4194304 196608 |
| UNIFIED_MRC_CACHE 4194304 135168 |
| RECOVERY_MRC_CACHE 4194304 65536 |
| RW_MRC_CACHE 4259840 65536 |
| RW_VAR_MRC_CACHE 4325376 4096 |
| RW_ELOG 4329472 12288 |
| RW_SHARED 4341760 16384 |
| SHARED_DATA 4341760 8192 |
| VBLOCK_DEV 4349952 8192 |
| RW_VPD 4358144 8192 |
| RW_NVRAM 4366336 24576 |
| RW_SECTION_A 4390912 4718592 |
| VBLOCK_A 4390912 65536 |
| FW_MAIN_A 4456448 4652992 |
| RW_FWID_A 9109440 64 |
| RW_SECTION_B 9109504 4718592 |
| VBLOCK_B 9109504 65536 |
| FW_MAIN_B 9175040 4652992 |
| RW_FWID_B 13828032 64 |
| RW_LEGACY 13828096 2097152 |
| BIOS_UNUSABLE 15925248 323584 |
| DEVICE_EXTENSION 16248832 524288 |
| UNUSED_HOLE 16773120 4096 |
| """ |
| |
| # Expected output from 'futility dump_fmap -p' for alternate main image. |
| # This FMAP contains EC_MAIN_A sections, which will alter |
| # the behavior of repack. A similar FMAP is used on some legacy Chrome OS |
| # devices. |
| FMAP_OUTPUT_LEGACY = """SI_ALL 0 2097152 |
| SI_DESC 0 4096 |
| SI_ME 4096 2093056 |
| SI_BIOS 2097152 6291456 |
| RW_SECTION_A 2097152 983040 |
| VBLOCK_A 2097152 65536 |
| FW_MAIN_A 2162688 720896 |
| EC_MAIN_A 2949120 131008 |
| RW_FWID_A 3080128 64 |
| RW_SECTION_B 3080192 983040 |
| VBLOCK_B 3080192 65536 |
| FW_MAIN_B 3145728 720896 |
| EC_MAIN_B 3932160 131008 |
| RW_FWID_B 4063168 64 |
| RW_MRC_CACHE 4063232 65536 |
| RW_ELOG 4128768 16384 |
| RW_SHARED 4145152 16384 |
| SHARED_DATA 4145152 8192 |
| VBLOCK_DEV 4153344 8192 |
| RW_VPD 4161536 8192 |
| RW_UNUSED 4169728 24576 |
| RW_LEGACY 4194304 2097152 |
| WP_RO 6291456 2097152 |
| RO_VPD 6291456 16384 |
| RO_UNUSED 6307840 49152 |
| RO_SECTION 6356992 2031616 |
| FMAP 6356992 2048 |
| RO_FRID 6359040 64 |
| RO_FRID_PAD 6359104 1984 |
| GBB 6361088 978944 |
| BOOT_STUB 7340032 1048576 |
| """ |
| |
| # Size of dummy 'ecrw' file. |
| ECRW_SIZE = 0x38000 |
| |
| # Expected output from 'futility dump_fmap -p' for EC image. |
| FMAP_OUTPUT_EC = """EC_RO 64 229376 |
| FR_MAIN 64 229376 |
| RO_FRID 388 32 |
| FMAP 135232 350 |
| WP_RO 0 262144 |
| EC_RW 262144 229376 |
| RW_FWID 262468 32 |
| """ |
| |
| # Common flags that we use in several tests. |
| _COMMON_FLAGS = [ |
| "-b", |
| "test/image.bin", |
| "-q", |
| "-o", |
| ] |
| |
| |
| # Use this to suppress stdout/stderr output: |
| # with capture_sys_output() as (stdout, stderr) |
| # ...do something... |
| @contextlib.contextmanager |
| def capture_sys_output(): |
| capture_out, capture_err = io.StringIO(), io.StringIO() |
| old_out, old_err = sys.stdout, sys.stderr |
| try: |
| sys.stdout, sys.stderr = capture_out, capture_err |
| yield capture_out, capture_err |
| finally: |
| sys.stdout, sys.stderr = old_out, old_err |
| |
| |
| class TestUnit(cros_test_lib.MockTempDirTestCase): |
| """Test cases for common program flows.""" |
| |
| def setUp(self): |
| self.output = os.path.join(self.tempdir, "out") |
| self.common_flags = _COMMON_FLAGS + [self.output] |
| |
| pack_firmware_utils.MakeTestFiles() |
| self.packer = pack_firmware.FirmwarePacker(".") |
| self._ExtractFrid = pack_firmware.FirmwarePacker._ExtractFrid |
| |
| def tearDown(self): |
| pack_firmware.FirmwarePacker._ExtractFrid = self._ExtractFrid |
| |
| def testBadStartup(self): |
| """Test various bad start-up conditions.""" |
| # Starting up in another directory (without required files) should fail. |
| with self.assertRaises(pack_firmware.PackError) as e: |
| pack_firmware.main(["/"]) |
| self.assertIn("'/pack/sfx2.sh'", str(e.exception)) |
| |
| # Should check for 'zip' tool. |
| with mock.patch.object(osutils, "Which", return_value=None): |
| with self.assertRaises(pack_firmware.PackError) as e: |
| pack_firmware.main(["."]) |
| self.assertIn("'zip'", str(e.exception)) |
| |
| # Should complain if we don't provide at least one image. |
| with self.assertRaises(pack_firmware.PackError) as e: |
| args = [".", "-L", "-o", "out"] |
| pack_firmware.main(args) |
| self.assertIn("Must assign at least one", str(e.exception)) |
| |
| def testArgParse(self): |
| """Test some basic argument parsing as a validity check.""" |
| with self.assertRaises(SystemExit): |
| with capture_sys_output(): |
| self.assertIsNone(self.packer.ParseArgs(["--invalid"])) |
| |
| self.assertIsNone(self.packer.ParseArgs([]).bios_image) |
| self.assertEqual( |
| "/bios.bin", self.packer.ParseArgs(["-b", "/bios.bin"]).bios_image |
| ) |
| |
| def testEnsureCommand(self): |
| """Check that we detect a missing command.""" |
| self.packer._EnsureCommand("ls", "sample-package") |
| with self.assertRaises(pack_firmware.PackError) as e: |
| self.packer._EnsureCommand("does-not-exist", "sample-package") |
| self.assertIn("You need 'does-not-exist'", str(e.exception)) |
| |
| def testTmpdirs(self): |
| """Check creation and removal of temporary directories.""" |
| dir1 = self.packer._CreateTmpDir() |
| dir2 = self.packer._CreateTmpDir() |
| self.assertExists(dir1) |
| self.assertExists(dir2) |
| self.packer._RemoveTmpdirs() |
| self.assertNotExists(dir1) |
| self.assertNotExists(dir2) |
| |
| def testAddVersionInfoMissingFile(self): |
| """Trying to add version info for a missing file should be detected.""" |
| with self.assertRaises(IOError) as e: |
| self.packer._AddVersionInfo("BIOS", "missing-file", "v123") |
| self.assertIn("'missing-file'", str(e.exception)) |
| |
| def testAddVersionInfoNoFile(self): |
| """Check adding version info with no filename.""" |
| self.packer._AddVersionInfo("BIOS", "", "v123") |
| self.assertEqual( |
| "BIOS version: v123\n", self.packer._versions.getvalue() |
| ) |
| |
| def testAddVersionNoVersion(self): |
| """Check adding version info with no version.""" |
| self.packer._AddVersionInfo("BIOS", "test/image.bin", "") |
| self.assertEqual( |
| "BIOS image: 8ce05b02847603aef6cfa01f1bab73d0 " |
| "*test/image.bin\n", |
| self.packer._versions.getvalue(), |
| ) |
| |
| def testAddVersionInfo(self): |
| """Check adding version info with both a filename and version.""" |
| self.packer._AddVersionInfo("BIOS", "test/image.bin", "v123") |
| self.assertEqual( |
| "BIOS image: 8ce05b02847603aef6cfa01f1bab73d0 " |
| "*test/image.bin\nBIOS version: v123\n", |
| self.packer._versions.getvalue(), |
| ) |
| |
| def testExtractFrid(self): |
| """Check extracting the firmware ID from a bios image.""" |
| self.packer._tmpdir = "test" |
| self.packer._args = self.packer.ParseArgs( |
| ["--bios_image", "image.bin", "-t"] |
| ) |
| with cros_test_lib.RunCommandMock() as rc: |
| rc.AddCmdResult( |
| partial_mock.ListRegex("futility dump_fmap"), returncode=0 |
| ) |
| self.assertEqual(RO_FRID, self.packer._ExtractFrid("image.bin")) |
| |
| def testExtractFridTrailingSpace(self): |
| """Check extracting a firmware ID with a trailing space.""" |
| |
| def _SetupImage(_, **kwargs): |
| destdir = kwargs["cwd"] |
| osutils.WriteFile( |
| os.path.join(destdir, "RO_FRID"), b"TESTING \0\0\0", mode="wb" |
| ) |
| |
| self.packer._tmpdir = self.packer._CreateTmpDir() |
| self.packer._args = self.packer.ParseArgs( |
| ["--bios_image", "image.bin", "-t"] |
| ) |
| with cros_test_lib.RunCommandMock() as rc: |
| rc.AddCmdResult( |
| partial_mock.ListRegex("futility dump_fmap"), |
| returncode=0, |
| side_effect=_SetupImage, |
| ) |
| self.assertEqual("TESTING ", self.packer._ExtractFrid("image.bin")) |
| self.packer._RemoveTmpdirs() |
| |
| def testExtractEcVersion(self): |
| """Check extracting version from firmware ID.""" |
| self.assertEqual(self.packer._ExtractEcVersion(EC_RO_FRID), "1-1-5857") |
| self.assertEqual( |
| self.packer._ExtractEcVersion(EC_RO_FRID_NEW), "9264-0-0" |
| ) |
| with self.assertRaises(pack_firmware.PackError) as e: |
| self.assertEqual(self.packer._ExtractEcVersion("a_bad_id"), "") |
| self.assertIn("Malformed EC firmware ID", str(e.exception)) |
| |
| def testExtractMainVersion(self): |
| """Check extracting version from firmware ID.""" |
| self.assertEqual(self.packer._ExtractMainVersion(RO_FRID), "9264-0-0") |
| self.assertEqual(self.packer._ExtractMainVersion(RW_FWID), "9264-0-0") |
| self.assertEqual( |
| self.packer._ExtractMainVersion(NO_TIMESTAMP_RO_FRID), "9264-0-1" |
| ) |
| with self.assertRaises(pack_firmware.PackError) as e: |
| self.assertEqual(self.packer._ExtractMainVersion("a_bad_id"), "") |
| self.assertIn("Malformed coreboot firmware ID", str(e.exception)) |
| |
| def testFirmwareImageOutput(self): |
| """Check firmware image output name.""" |
| self.packer._args = self.packer.ParseArgs([]) |
| self.packer._tmpdir = self.packer._CreateTmpDir() |
| |
| tag = "ec" |
| target = "reef" |
| fw_ids = pack_firmware.FirmwareIds(EC_RO_FRID, EC_RW_FWID) |
| bad_fw_ids = pack_firmware.FirmwareIds(EC_RO_FRID, None) |
| version_fn = ( |
| lambda fwid: "1-1-5857" if fwid == EC_RO_FRID else "1-1-5858" |
| ) |
| self.assertEqual(self.packer._FirmwareImageOutput(tag), "") |
| self.assertEqual( |
| self.packer._FirmwareImageOutput( |
| tag, fw_ids=fw_ids, extract_version=version_fn |
| ), |
| "", |
| ) |
| self.assertEqual( |
| self.packer._FirmwareImageOutput(tag, target, fw_ids), "" |
| ) |
| self.assertEqual( |
| self.packer._FirmwareImageOutput( |
| tag, target, extract_version=version_fn |
| ), |
| "", |
| ) |
| self.assertEqual( |
| self.packer._FirmwareImageOutput( |
| tag, target, bad_fw_ids, version_fn |
| ), |
| "", |
| ) |
| |
| expected_fname = "ec-reef.ro-1-1-5857.rw-1-1-5858.bin" |
| self.assertEqual( |
| self.packer._FirmwareImageOutput(tag, target, fw_ids, version_fn), |
| expected_fname, |
| ) |
| self.assertEqual( |
| self.packer._FirmwareImageOutput( |
| tag, target, fw_ids, version_fn, self.packer._tmpdir |
| ), |
| os.path.join(self.packer._tmpdir, expected_fname), |
| ) |
| |
| self.packer._RemoveTmpdirs() |
| |
| def testFirmwareImageOutputLegacy(self): |
| """Check firmware image output name when legacy is set.""" |
| self.packer._args = self.packer.ParseArgs(["-L"]) |
| self.packer._tmpdir = self.packer._CreateTmpDir() |
| self.assertEqual(self.packer._FirmwareImageOutput("bios"), "bios.bin") |
| self.assertEqual( |
| self.packer._FirmwareImageOutput("bios", "reef"), "bios.bin" |
| ) |
| self.assertEqual( |
| self.packer._FirmwareImageOutput( |
| tag="bios", target_dir=self.packer._tmpdir |
| ), |
| os.path.join(self.packer._tmpdir, "bios.bin"), |
| ) |
| self.packer._RemoveTmpdirs() |
| |
| def testUntarFile(self): |
| """Test operation of the tar file unpacker.""" |
| self.packer._tmpdir = self.packer._CreateTmpDir() |
| dirname = self.packer._CreateTmpDir() |
| fname = self.packer._UntarFile("functest/Reef.9042.50.0.tbz2", dirname) |
| self.assertEqual(os.path.basename(fname), "image.bin") |
| |
| # Unpack again with a different suffix. We should get a different |
| # filename and the file contents should be different. |
| fname2 = self.packer._UntarFile( |
| "functest/Reef.9000.0.0.tbz2", dirname, "-rw" |
| ) |
| self.assertEqual(os.path.basename(fname2), "image.bin-rw") |
| self.assertNotEqual(fname, fname2) |
| data = osutils.ReadFile(fname, mode="rb") |
| data2 = osutils.ReadFile(fname2, mode="rb") |
| self.assertNotEqual(data, data2) |
| |
| dirname = self.packer._CreateTmpDir() |
| fname = self.packer._UntarFile("functest/Reef.9042.50.0.tbz2", dirname) |
| self.assertEqual(os.path.basename(fname), "image.bin") |
| |
| # This tar file has two files in it. |
| # -rw-r----- sjg/eng 64 2017-03-03 16:12 RO_FRID |
| # -rw-r----- sjg/eng 64 2017-03-15 13:38 RW_FRID |
| with self.assertRaises(pack_firmware.PackError) as e: |
| fname = self.packer._UntarFile("test/two_files.tbz2", dirname) |
| self.assertIn("Expected 1 member", str(e.exception)) |
| |
| # This tar file has as directory name in its member's filename. |
| # -rw-r----- sjg/eng 64 2017-03-03 16:12 test/RO_FRID |
| with self.assertRaises(pack_firmware.PackError) as e: |
| fname = self.packer._UntarFile("test/path.tbz2", dirname) |
| self.assertIn("should be a simple name", str(e.exception)) |
| |
| self.packer._RemoveTmpdirs() |
| |
| @staticmethod |
| def _FilesInDir(dirname): |
| """Get a list of files in a directory. |
| |
| Args: |
| dirname: Directory name to check. |
| |
| Returns: |
| List of files in that directory (basename only). Any subdirectories |
| are ignored. |
| """ |
| return sorted( |
| [ |
| os.path.basename(fname) |
| for fname in glob.glob(os.path.join(dirname, "*")) |
| if not os.path.isdir(fname) |
| ] |
| ) |
| |
| def testBaseDirPath(self): |
| """Check that _BaseDirPath() works as expected.""" |
| self.packer._basedir = "base" |
| self.assertEqual("base/fred", self.packer._BaseDirPath("fred")) |
| |
| def _GetFakeReefFirmware(self): |
| """Get the fake reef firmware config. |
| |
| Returns: |
| Dict of the reef firmware config |
| """ |
| return { |
| "ec-ro-image": "bcs://Reef_EC.9042.50.0.tbz2", |
| "extra": [ |
| "${FILESDIR}/extra", |
| "${SYSROOT}/usr/sbin/ectool", |
| "bcs://Reef.9000.0.0.tbz2", |
| ], |
| "main-ro-image": "bcs://Reef.9042.50.0.tbz2", |
| } |
| |
| def testExtractFileBcs(self): |
| """Test handling file extraction based on a configuration property,""" |
| self.packer._tmpdir = self.packer._CreateTmpDir() |
| self.packer._args = self.packer.ParseArgs(["--imagedir", "functest"]) |
| dirname = self.packer._CreateTmpDir() |
| fake_fw = self._GetFakeReefFirmware() |
| |
| # This should look up main-ro-image, find that file in functest/, copy |
| # it to our directory and return its filename. |
| main_image = fake_fw["main-ro-image"] |
| self.assertEqual( |
| self.packer._ExtractFile(None, None, main_image, dirname), |
| os.path.join(dirname, "image.bin"), |
| ) |
| ec_image = fake_fw["ec-ro-image"] |
| self.assertEqual( |
| self.packer._ExtractFile(None, None, ec_image, dirname), |
| os.path.join(dirname, "ec.bin"), |
| ) |
| self.packer._RemoveTmpdirs() |
| |
| @staticmethod |
| def _AddMocks(rc): |
| def _CopySections(_, **kwargs): |
| destdir = kwargs["cwd"] |
| for fname in ["RO_FRID", "RW_FWID"]: |
| shutil.copy2(os.path.join("test", fname), destdir) |
| |
| rc.AddCmdResult( |
| partial_mock.ListRegex(r"(?:^|\s)file(?:$|\s)"), |
| returncode=0, |
| stdout="ELF 64-bit LSB executable, etc.\n", |
| ) |
| rc.AddCmdResult( |
| partial_mock.ListRegex( |
| r"futility dump_fmap -x .*image\.bin (?:RO_FRID|RW_FWID)$" |
| ), |
| side_effect=_CopySections, |
| returncode=0, |
| ) |
| rc.AddCmdResult( |
| partial_mock.ListRegex("futility gbb"), |
| returncode=0, |
| stdout=" - exported root_key to file: rootkey.bin", |
| ) |
| rc.AddCmdResult(partial_mock.ListRegex("--repack"), returncode=0) |
| rc.AddCmdResult( |
| partial_mock.ListRegex(r"futility dump_fmap -x .*ec\.bin"), |
| side_effect=_CopySections, |
| returncode=0, |
| ) |
| |
| @staticmethod |
| def _CreateCbfstoolFile(cmd, **_kwargs): |
| """Called as a side effect to emulate the effect of cbfstool. |
| |
| This handles the 'cbfstool...extract' command which is supposed to |
| extract a particular 'file' from inside the CBFS archive. We deal with |
| this by creating a zero-filled file with the correct name and size. |
| See _ExtractEcRwUsingCbfs() for where this command is generated. |
| |
| Args: |
| cmd: Arguments, of the form: |
| ['cbfstool.sh', ..., '-f', <filename>, ...] |
| See _SetPreambleFlags() for where this is generated. |
| """ |
| file_arg = cmd.index("-f") |
| fname = cmd[file_arg + 1] |
| with open(fname, "wb") as fd: |
| fd.truncate(ECRW_SIZE) |
| |
| @staticmethod |
| def _CreateDumpfmapFile(cmd, **_kwargs): |
| """Called as a side effect to emulate the effect of dump_fmap. |
| |
| This handles the 'dump_fmap -x' command which is supposed to |
| extract a particular region from a file with an FMAP descriptor. |
| See _ExtractEcRwUsingFMAP() for where this command is generated. |
| |
| Args: |
| cmd: Arguments, of the form: |
| ['dump_fmap', '-x', <filename>, <region>] |
| <region> specifies the region to extract from <filename>, which |
| will be extracted to cwd in a file named <region>. |
| See _ExtractEcRwUsingFMAP() for where this is generated. |
| """ |
| fname = os.path.join(_kwargs["cwd"], cmd.pop()) |
| with open(fname, "wb") as fd: |
| # Write a dummy header with image size = ECRW_SIZE, and payload of |
| # zeros |
| fd.write(struct.pack("<III", 1, 12, ECRW_SIZE)) |
| fd.truncate(ECRW_SIZE + 12) |
| |
| @classmethod |
| def _AddMergeMocks(cls, rc, mocked_dump_fmap_output): |
| rc.AddCmdResult( |
| partial_mock.ListRegex( |
| r"futility dump_fmap -x .*/images-merged/.*image_rw\.bin" |
| ), |
| returncode=0, |
| ) |
| rc.AddCmdResult( |
| partial_mock.ListRegex( |
| r"futility dump_fmap -p .*/images-merged/.*image_rw\.bin" |
| ), |
| returncode=0, |
| stdout=mocked_dump_fmap_output, |
| ) |
| rc.AddCmdResult( |
| partial_mock.ListRegex(r"futility dump_fmap -p .*image\.binrw"), |
| returncode=0, |
| stdout=mocked_dump_fmap_output, |
| ) |
| rc.AddCmdResult( |
| partial_mock.ListRegex(r"futility dump_fmap -p .*image\.bin"), |
| returncode=0, |
| stdout=mocked_dump_fmap_output, |
| ) |
| rc.AddCmdResult(partial_mock.Regex("extract_ecrw"), returncode=0) |
| rc.AddCmdResult( |
| partial_mock.ListRegex(r"futility dump_fmap -p .*ec\.bin"), |
| returncode=0, |
| stdout=FMAP_OUTPUT_EC, |
| ) |
| rc.AddCmdResult( |
| partial_mock.ListRegex("cbfstool"), |
| returncode=0, |
| side_effect=cls._CreateCbfstoolFile, |
| ) |
| rc.AddCmdResult( |
| partial_mock.ListRegex( |
| r"futility dump_fmap -x .*image\.bin .*_MAIN_A" |
| ), |
| returncode=0, |
| side_effect=cls._CreateDumpfmapFile, |
| ) |
| |
| def testMockedRun(self): |
| """Start up with a valid updater script and BIOS.""" |
| args = [".", "-L", "-e", "test/ec.bin"] + self.common_flags |
| with cros_test_lib.RunCommandMock() as rc: |
| self._AddMocks(rc) |
| firmware_unittest.MockFirmwareSigner(rc) |
| pack_firmware.main(args) |
| pack_firmware.packer._versions.getvalue().splitlines() |
| |
| def _testMockedRunWithMerge(self, mocked_dump_fmap_output): |
| args = [ |
| "--bios_rw_image", |
| "test/image_rw.bin", |
| "-L", |
| "-e", |
| "test/ec.bin", |
| ] + self.common_flags |
| with cros_test_lib.RunCommandMock() as rc: |
| self._AddMocks(rc) |
| self._AddMergeMocks(rc, mocked_dump_fmap_output) |
| self.packer.Start(args, remove_tmpdirs=False) |
| result = self.packer._versions.getvalue().splitlines() |
| self.assertEqual(8, len(result)) |
| self.assertIn(RO_FRID, self._FindLineInList(result, "EC version")) |
| self.assertIn(RW_FWID, self._FindLineInList(result, "EC (RW) version")) |
| rw_fname = self.packer._BaseDirPath("ec.bin") |
| self.assertAlmostEqual( |
| os.stat(rw_fname).st_mtime, os.stat("test/image_rw.bin").st_mtime |
| ) |
| ec_fname = self.packer._BaseDirPath("ec.bin") |
| self.assertAlmostEqual( |
| os.stat(ec_fname).st_mtime, os.stat("test/image_rw.bin").st_mtime |
| ) |
| self.packer._RemoveTmpdirs() |
| |
| def testMockedRunWithMerge(self): |
| """Start up with a valid updater script and merge the RW BIOS.""" |
| self._testMockedRunWithMerge(FMAP_OUTPUT) |
| |
| def testMockedRunWithMergeLegacyFmap(self): |
| """Repeat merge test with alternate FMAP used on legacy devices.""" |
| self._testMockedRunWithMerge(FMAP_OUTPUT_LEGACY) |
| |
| def testMockedRunUnibuildBad(self): |
| """Try unified build options with invalid arguments.""" |
| |
| args = [".", "-m", "reef", "-o", "output"] |
| with self.assertRaises(pack_firmware.PackError) as e: |
| pack_firmware.main(args) |
| self.assertIn("Missing model configuration file", str(e.exception)) |
| |
| def SetupRunWithUnibuild(self, config_fname): |
| """Set up to run with a valid updater script and BIOS. |
| |
| Args: |
| config_fname: Model configuration file to use. |
| |
| Returns: |
| List of arguments to pass to pack_firmware.main() |
| """ |
| |
| args = [ |
| ".", |
| "-m", |
| "reef", |
| "-m", |
| "pyro", |
| "-q", |
| "-o", |
| self.output, |
| "-c", |
| "test/%s" % config_fname, |
| "-i", |
| "functest", |
| "-t", |
| ] |
| |
| os.environ["SYSROOT"] = "test" |
| os.environ["FILESDIR"] = "test" |
| return args |
| |
| def testMockedRunWithUnibuild(self): |
| """Start up with a valid updater script and BIOS.""" |
| args = self.SetupRunWithUnibuild("config.yaml") |
| with cros_test_lib.RunCommandMock() as rc: |
| self._AddMocks(rc) |
| pack_firmware.main(args) |
| pack_firmware.packer._versions.getvalue().splitlines() |
| |
| def testMockedRunWithUnibuildMixedUris(self): |
| """Start up with config where a subset of devices have firmware uris.""" |
| args = self.SetupRunWithUnibuild("config_mixed_uri.yaml") |
| with cros_test_lib.RunCommandMock() as rc: |
| self._AddMocks(rc) |
| pack_firmware.main(args) |
| # Only reef is in the output, configs without firmware uris are |
| # skipped. |
| self.assertListEqual( |
| pack_firmware.packer._versions.getvalue().strip().splitlines(), |
| [ |
| "Model: reef", |
| "BIOS image: 99a6fc64e45596aa2c1a9911cddce952" |
| " */reef/image.bin", |
| "BIOS version: Google_Reef.9264.0.0_d2017_02_09_1240", |
| "EC image: 60c08e5aefa3a660687c7027d1358df0" |
| " */reef/ec.bin", |
| "EC version: Google_Reef.9264.0.0_d2017_02_09_1240", |
| "EC (RW) version: Google_Reef.9264.0.0_d2017_02_09_1250", |
| ], |
| ) |
| |
| def testMockedRunWithUnibuildMerge(self): |
| """Start up with a valid updater script and both RO and RW BIOS.""" |
| |
| # Due to a bug in the DT impl, the RW firmware image was never actually |
| # present. |
| # TODO(sjg): Change this to config_rw.json once the RW merge case if |
| # correctly supported. |
| args = self.SetupRunWithUnibuild("config.yaml") |
| with cros_test_lib.RunCommandMock() as rc: |
| self._AddMocks(rc) |
| self._AddMergeMocks(rc, FMAP_OUTPUT) |
| pack_firmware.main(args) |
| pack_firmware.packer._versions.getvalue().splitlines() |
| |
| def _FindLineInList(self, lines, start_text): |
| """Find a single line starting with the given text and return it. |
| |
| Args: |
| lines: List of lines to check. |
| start_text: Text to find. |
| |
| Returns: |
| Line found, as a string (or assertion failure if exactly one |
| matching line was not found). |
| """ |
| found = [line for line in lines if line.strip().startswith(start_text)] |
| self.assertEqual(len(found), 1) |
| return found[0] |
| |
| def testNoECFirmware(self): |
| """Simple test of creating firmware without an EC image.""" |
| args = self.common_flags + ["-L"] |
| with cros_test_lib.RunCommandMock() as rc: |
| self._AddMocks(rc) |
| self.packer.Start(args) |
| |
| # There should be no EC version in the VERSION file. |
| result = self.packer._versions.getvalue() |
| self.assertNotIn("EC version", result) |
| self.assertEqual(4, len(result.splitlines())) |
| |
| |
| if __name__ == "__main__": |
| cros_test_lib.main(module=__name__) |
