| #!/usr/bin/env python3 |
| # -*- coding: utf-8 -*- |
| # Copyright 2017 The Chromium OS Authors. All rights reserved. |
| # 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. |
| """ |
| |
| from __future__ import print_function |
| |
| from contextlib import contextmanager |
| import glob |
| import os |
| import shutil |
| import struct |
| import sys |
| |
| import mock |
| from six.moves import StringIO |
| |
| 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 |
| import pack_firmware |
| import pack_firmware_utils |
| |
| # 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.2017_02_09_1240' |
| RW_FWID = 'Google_Reef.9264.0.2017_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' |
| |
| # Expected output from vbutil. |
| VBUTIL_OUTPUT = """Key block: |
| Size: 2232 |
| Flags: 7 (ignored) |
| Data key algorithm: 7 RSA4096 SHA256 |
| Data key version: 1 |
| Data key sha1sum: e2c1c92d7d7aa7dfed5e8375edd30b7ae52b7450 |
| Preamble: |
| Size: 2164 |
| Header version: 2.1 |
| Firmware version: 1 |
| Kernel key algorithm: 7 RSA4096 SHA256 |
| Kernel key version: 1 |
| Kernel key sha1sum: 5d2b220899c4403d564092ada3f12d3cc4483223 |
| Firmware body size: 920000 |
| Preamble flags: 1 |
| Body verification succeeded. |
| """ |
| |
| # 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 and PD_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 |
| PD_MAIN_A 2883584 65536 |
| EC_MAIN_A 2949120 131008 |
| RW_FWID_A 3080128 64 |
| RW_SECTION_B 3080192 983040 |
| VBLOCK_B 3080192 65536 |
| FW_MAIN_B 3145728 720896 |
| PD_MAIN_B 3866624 65536 |
| 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... |
| @contextmanager |
| def capture_sys_output(): |
| capture_out, capture_err = StringIO(), 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('.') |
| # Limit the resolution of timestamps to aid comparison. |
| os.stat_float_times(False) |
| 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 sanity 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') |
| 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') |
| self.assertEqual(self.packer._ExtractMainVersion(RW_FWID), '9264-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('file'), returncode=0, |
| output='ELF 64-bit LSB executable, etc.\n') |
| rc.AddCmdResult( |
| partial_mock.ListRegex('futility dump_fmap -x .*image.bin$'), |
| side_effect=_CopySections, returncode=0) |
| rc.AddCmdResult(partial_mock.ListRegex('futility gbb'), returncode=0, |
| output=' - exported root_key to file: rootkey.bin') |
| rc.AddCmdResult( |
| partial_mock.ListRegex('futility vbutil_firmware'), |
| returncode=0, output=VBUTIL_OUTPUT) |
| rc.AddCmdResult(partial_mock.ListRegex('--repack'), returncode=0) |
| rc.AddCmdResult(partial_mock.ListRegex('futility dump_fmap -x .*ec.bin'), |
| side_effect=_CopySections, returncode=0) |
| rc.AddCmdResult(partial_mock.ListRegex('futility dump_fmap -x .*pd.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( |
| 'futility dump_fmap -x .*/images-merged/.*image_rw.bin'), returncode=0) |
| rc.AddCmdResult( |
| partial_mock.ListRegex( |
| 'futility dump_fmap -p .*/images-merged/.*image_rw.bin'), |
| returncode=0, output=mocked_dump_fmap_output) |
| rc.AddCmdResult( |
| partial_mock.ListRegex('futility dump_fmap -p .*image.binrw'), |
| returncode=0, output=mocked_dump_fmap_output) |
| rc.AddCmdResult( |
| partial_mock.ListRegex('futility dump_fmap -p .*image.bin'), |
| returncode=0, output=mocked_dump_fmap_output) |
| rc.AddCmdResult(partial_mock.Regex('extract_ecrw'), returncode=0) |
| rc.AddCmdResult(partial_mock.ListRegex('futility dump_fmap -p .*ec.bin'), |
| returncode=0, output=FMAP_OUTPUT_EC) |
| rc.AddCmdResult(partial_mock.ListRegex('cbfstool'), returncode=0, |
| side_effect=cls._CreateCbfstoolFile) |
| rc.AddCmdResult(partial_mock.ListRegex('futility dump_fmap -p .*pd.bin'), |
| returncode=0, output=FMAP_OUTPUT_EC) |
| rc.AddCmdResult( |
| partial_mock.ListRegex('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', '-p', 'test/pd.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(11, 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.assertEqual(os.stat(rw_fname).st_mtime, |
| os.stat('test/image_rw.bin').st_mtime) |
| ec_fname = self.packer._BaseDirPath('ec.bin') |
| self.assertEqual(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 master configuration file', str(e.exception)) |
| |
| def SetupRunWithUnibuild(self, config_fname): |
| """Set up to run with a valid updater script and BIOS. |
| |
| Args: |
| config_fname: Master 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.2017_02_09_1240', |
| 'EC image: 60c08e5aefa3a660687c7027d1358df0 */reef/ec.bin', |
| 'EC version: Google_Reef.9264.0.2017_02_09_1240', |
| 'EC (RW) version: Google_Reef.9264.0.2017_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): |
| """Helper to 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__) |
