| #!/usr/bin/env python3 |
| # -*- coding: utf-8 -*- |
| # Copyright 2020 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. |
| # pylint: disable=unused-argument |
| |
| """Unit tests for ConfigFS data file generator.""" |
| |
| from __future__ import print_function |
| |
| import functools |
| import json |
| import os |
| import struct |
| import subprocess |
| import tempfile |
| import configfs |
| |
| from chromite.lib import cros_test_lib |
| from chromite.lib import osutils |
| |
| this_dir = os.path.dirname(__file__) |
| |
| |
| def TestConfigs(*args): |
| """Wrapper function for tests which use configs from libcros_config/ |
| |
| Use like so: |
| @TestConfigs('test.json', [any other files you want...]) |
| def testFoo(self, config_filename, config, output_dir): |
| # do something! |
| pass |
| """ |
| def _Decorator(method): |
| @functools.wraps(method) |
| def _Wrapper(self): |
| for filename in args: |
| with open(os.path.join(this_dir, '../test_data', filename)) as f: |
| config = json.load(f) |
| |
| with tempfile.TemporaryDirectory(prefix='test.') as output_dir: |
| squashfs_img = os.path.join(output_dir, 'configfs.img') |
| configfs.GenerateConfigFSData(config, squashfs_img) |
| subprocess.run(['unsquashfs', squashfs_img], check=True, |
| cwd=output_dir, stdout=subprocess.PIPE) |
| method(self, filename, config, output_dir) |
| return _Wrapper |
| return _Decorator |
| |
| |
| class ConfigFSTests(cros_test_lib.TestCase): |
| """Tests for ConfigFS.""" |
| |
| def testSerialize(self): |
| self.assertEqual(configfs.Serialize(True), b'true') |
| self.assertEqual(configfs.Serialize(False), b'false') |
| self.assertEqual(configfs.Serialize(10), b'10') |
| self.assertEqual(configfs.Serialize('hello💩'), b'hello\xf0\x9f\x92\xa9') |
| self.assertEqual(configfs.Serialize(b'\xff\xff\xff'), b'\xff\xff\xff') |
| |
| @TestConfigs('test.json', 'test_arm.json') |
| def testConfigV1FileStructure(self, filename, config, output_dir): |
| def _CheckConfigRec(config, path): |
| if isinstance(config, dict): |
| iterator = config.items() |
| elif isinstance(config, list): |
| iterator = enumerate(config) |
| else: |
| self.assertTrue(os.path.isfile(path)) |
| self.assertEqual(osutils.ReadFile(path, mode='rb'), |
| configfs.Serialize(config)) |
| return |
| self.assertTrue(os.path.isdir(path)) |
| for name, entry in iterator: |
| childpath = os.path.join(path, str(name)) |
| _CheckConfigRec(entry, childpath) |
| _CheckConfigRec(config, os.path.join(output_dir, 'squashfs-root/v1')) |
| |
| # TODO(jrosenth): remove once we've fully moved over to struct-based |
| # identity. |
| @TestConfigs('test.json', 'test_arm.json') |
| def testConfigV1IdentityJson(self, filename, config, output_dir): |
| identity_path = os.path.join(output_dir, 'squashfs-root/v1/identity.json') |
| self.assertTrue(os.path.isfile(identity_path)) |
| with open(identity_path) as f: |
| identity_data = json.load(f) |
| for device_config, identity_config in zip( |
| config['chromeos']['configs'], identity_data['chromeos']['configs']): |
| self.assertEqual(set(identity_config.keys()), {'identity'}) |
| self.assertEqual(device_config['identity'], identity_config['identity']) |
| |
| def testConfigIdentityStructSizes(self): |
| self.assertEqual(struct.calcsize(configfs.HEADER_FORMAT), 16) |
| self.assertEqual(struct.calcsize(configfs.ENTRY_FORMAT), 16) |
| |
| @TestConfigs('test.json', 'test_arm.json') |
| def testConfigIdentityV0(self, filename, config, output_dir): |
| device_configs = config['chromeos']['configs'] |
| identity_path = os.path.join(output_dir, 'squashfs-root/identity.bin') |
| identity_bin = osutils.ReadFile(identity_path, mode='rb') |
| version, identity_type, entry_count = struct.unpack_from( |
| configfs.HEADER_FORMAT, identity_bin) |
| offset = struct.calcsize(configfs.HEADER_FORMAT) |
| identity_type = configfs.IdentityType(identity_type) |
| |
| self.assertEqual(version, configfs.STRUCT_VERSION) |
| if 'arm' in filename: |
| self.assertEqual(identity_type, configfs.IdentityType.ARM) |
| else: |
| self.assertEqual(identity_type, configfs.IdentityType.X86) |
| self.assertEqual(len(device_configs), entry_count) |
| |
| # Get an entry from the string table. |
| def _GetString(offset): |
| base = (struct.calcsize(configfs.HEADER_FORMAT) |
| + struct.calcsize(configfs.ENTRY_FORMAT) * entry_count) |
| string, _, _ = identity_bin[base + offset:].partition(b'\000') |
| return string.decode('utf-8') |
| |
| for device in device_configs: |
| flags, model_match_offset, sku_id, whitelabel_offset = struct.unpack_from( |
| configfs.ENTRY_FORMAT, identity_bin, offset=offset) |
| offset += struct.calcsize(configfs.ENTRY_FORMAT) |
| |
| if identity_type == configfs.IdentityType.X86: |
| self.assertEqual( |
| flags & configfs.EntryFlags.USES_FIRMWARE_NAME.value, 0) |
| |
| if 'smbios-name-match' in device['identity']: |
| self.assertEqual(flags & configfs.EntryFlags.HAS_SMBIOS_NAME.value, |
| configfs.EntryFlags.HAS_SMBIOS_NAME.value) |
| self.assertEqual(identity_type, configfs.IdentityType.X86) |
| self.assertEqual(_GetString(model_match_offset), |
| device['identity']['smbios-name-match'].lower()) |
| |
| if 'device-tree-compatible-match' in device['identity']: |
| self.assertEqual(identity_type, configfs.IdentityType.ARM) |
| self.assertEqual( |
| _GetString(model_match_offset), |
| device['identity']['device-tree-compatible-match'].lower()) |
| |
| if 'firmware-name' in device['identity']: |
| self.assertEqual(flags & configfs.EntryFlags.USES_FIRMWARE_NAME.value, |
| configfs.EntryFlags.USES_FIRMWARE_NAME.value) |
| self.assertEqual(identity_type, configfs.IdentityType.ARM) |
| self.assertEqual(_GetString(model_match_offset), |
| device['identity']['firmware-name'].lower()) |
| else: |
| self.assertEqual( |
| flags & configfs.EntryFlags.USES_FIRMWARE_NAME.value, 0) |
| |
| if 'sku-id' in device['identity']: |
| self.assertEqual(flags & configfs.EntryFlags.HAS_SKU_ID.value, |
| configfs.EntryFlags.HAS_SKU_ID.value) |
| self.assertEqual(sku_id, device['identity']['sku-id']) |
| else: |
| self.assertEqual(flags & configfs.EntryFlags.HAS_SKU_ID.value, 0) |
| |
| if 'whitelabel-tag' in device['identity']: |
| self.assertEqual(flags & configfs.EntryFlags.HAS_WHITELABEL.value, |
| configfs.EntryFlags.HAS_WHITELABEL.value) |
| self.assertEqual(_GetString(whitelabel_offset), |
| device['identity']['whitelabel-tag'].lower()) |
| else: |
| self.assertEqual( |
| flags & configfs.EntryFlags.HAS_WHITELABEL.value, 0) |
| |
| if 'customization-id' in device['identity']: |
| self.assertEqual( |
| flags & configfs.EntryFlags.USES_CUSTOMIZATION_ID.value, |
| configfs.EntryFlags.USES_CUSTOMIZATION_ID.value) |
| self.assertEqual(_GetString(whitelabel_offset), |
| device['identity']['customization-id'].lower()) |
| else: |
| self.assertEqual( |
| flags & configfs.EntryFlags.USES_CUSTOMIZATION_ID.value, 0) |
| |
| if __name__ == '__main__': |
| cros_test_lib.main(module=__name__) |
