chromeos-config/crosid/tests/test_e2e.py

# Copyright 2021 The ChromiumOS Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""Test the crosid tool end-to-end."""

import shlex
import struct
import subprocess

import cros_config_host.identity_table  # pylint: disable=import-error
import pytest  # pylint: disable=wrong-import-order


def getvars(output):
    """Get a dictionary from the output of crosid."""
    result = {}
    for word in shlex.split(output):
        key, _, value = word.partition("=")
        result[key] = value
    return result


def make_config(
    model_name,
    frid_match=None,
    sku_id=None,
    customization_id=None,
    custom_label_tag=None,
):
    identity = {}
    if frid_match is not None:
        identity["frid"] = frid_match
    if sku_id is not None:
        identity["sku-id"] = sku_id
    if customization_id is not None:
        identity["customization-id"] = customization_id
    if custom_label_tag is not None:
        identity["custom-label-tag"] = custom_label_tag
    return {
        "name": model_name,
        "identity": identity,
    }


def make_fake_sysroot(
    path,
    smbios_sku=None,
    fdt_sku=None,
    acpi_frid=None,
    fdt_frid=None,
    vpd_values=None,
    configs=(),
):
    smbios_sysfs_path = path / "sys" / "class" / "dmi" / "id"
    if smbios_sku is not None:
        smbios_sysfs_path.mkdir(exist_ok=True, parents=True)
        (smbios_sysfs_path / "product_sku").write_text(f"sku{smbios_sku}\n")

    proc_fdt_path = path / "proc" / "device-tree"
    proc_fdt_coreboot_path = proc_fdt_path / "firmware" / "coreboot"
    if fdt_sku is not None:
        proc_fdt_coreboot_path.mkdir(exist_ok=True, parents=True)
        contents = fdt_sku.to_bytes(4, byteorder="big")
        (proc_fdt_coreboot_path / "sku-id").write_bytes(contents)

    proc_fdt_chromeos_path = proc_fdt_path / "firmware" / "chromeos"
    if fdt_frid is not None:
        proc_fdt_chromeos_path.mkdir(exist_ok=True, parents=True)
        (proc_fdt_chromeos_path / "readonly-firmware-version").write_text(
            fdt_frid
        )

    # Leave it use legacy path.  Once we completely switched to use current
    # chromeos_acpi driver, change the path to "GOOG0016:00".
    chromeos_acpi_path = path / "sys" / "devices" / "platform" / "chromeos_acpi"
    if acpi_frid is not None:
        chromeos_acpi_path.mkdir(exist_ok=True, parents=True)
        (chromeos_acpi_path / "FRID").write_text(acpi_frid)

    if vpd_values:
        vpd_sysfs_path = path / "sys" / "firmware" / "vpd" / "ro"
        vpd_sysfs_path.mkdir(exist_ok=True, parents=True)
        for name, value in vpd_values.items():
            (vpd_sysfs_path / name).write_text(value)

    configs_full = {"chromeos": {"configs": configs}}
    config_path = path / "usr" / "share" / "chromeos-config"
    config_path.mkdir(exist_ok=True, parents=True)
    with open(config_path / "identity.bin", "wb") as output_file:
        cros_config_host.identity_table.WriteIdentityStruct(
            configs_full, output_file
        )


REEF_CONFIGS = [
    make_config(
        "electro",
        frid_match="Google_Reef",
        sku_id=8,
        customization_id="PARMA-ELECTRO",
    ),
    make_config(
        "basking",
        frid_match="Google_Reef",
        sku_id=0,
        customization_id="OEM2-BASKING",
    ),
    make_config(
        "pyro",
        frid_match="Google_Pyro",
        customization_id="NEWTON2-PYRO",
    ),
    make_config(
        "sand",
        frid_match="Google_Sand",
        customization_id="ACER-SAND",
    ),
    make_config(
        "alan",
        frid_match="Google_Snappy",
        sku_id=7,
        customization_id="DOLPHIN-ALAN",
    ),
    make_config(
        "bigdaddy",
        frid_match="Google_Snappy",
        sku_id=2,
        customization_id="BENTLEY-BIGDADDY",
    ),
    make_config(
        "bigdaddy",
        frid_match="Google_Snappy",
        sku_id=5,
        customization_id="BENTLEY-BIGDADDY",
    ),
    make_config(
        "snappy",
        frid_match="Google_Snappy",
        sku_id=8,
        customization_id="MORGAN-SNAPPY",
    ),
    make_config(
        "snappy",
        frid_match="Google_Snappy",
    ),
]


@pytest.mark.parametrize("config_idx", list(range(len(REEF_CONFIGS))))
def test_reef(tmp_path, executable_path, config_idx):
    cfg = REEF_CONFIGS[config_idx]
    identity = cfg["identity"]
    vpd = {}

    customization_id = identity.get("customization-id")
    if customization_id:
        vpd["customization_id"] = customization_id

    make_fake_sysroot(
        tmp_path,
        acpi_frid=f"{identity['frid']}.1234_5678_910.1234.B",
        smbios_sku=identity.get("sku-id"),
        vpd_values=vpd,
        configs=REEF_CONFIGS,
    )

    result = subprocess.run(
        [executable_path, "--sysroot", tmp_path, "-v"],
        check=True,
        stdin=subprocess.DEVNULL,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        encoding="utf-8",
    )

    assert getvars(result.stdout) == {
        "SKU": str(identity.get("sku-id", "none")),
        "CONFIG_INDEX": str(config_idx),
        "FIRMWARE_MANIFEST_KEY": cfg["name"],
    }


def test_no_match(tmp_path, executable_path):
    # Test the case that no configs match (e.g., running wrong image
    # on device)
    make_fake_sysroot(
        tmp_path,
        acpi_frid="Google_Samus.1234_567_890.ohea",
        configs=REEF_CONFIGS,
    )

    # pylint: disable=subprocess-run-check
    result = subprocess.run(
        [executable_path, "--sysroot", tmp_path, "-v"],
        stdin=subprocess.DEVNULL,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        encoding="utf-8",
    )

    assert result.returncode != 0
    assert getvars(result.stdout) == {
        "SKU": "none",
        "CONFIG_INDEX": "unknown",
        "FIRMWARE_MANIFEST_KEY": "",
    }


def test_both_customization_id_and_whitelabel(tmp_path, executable_path):
    # Having both a customization_id and custom_label_tag indicates the
    # RO VPD was tampered/corrupted, and should result in errors.
    make_fake_sysroot(
        tmp_path,
        acpi_frid="Google_Sand.1234_5678_90.AAAA.B",
        vpd_values={
            "customization_id": "ACER-SAND",
            "whitelabel_tag": "some_wl",
        },
        configs=REEF_CONFIGS,
    )

    # pylint: disable=subprocess-run-check
    result = subprocess.run(
        [executable_path, "--sysroot", tmp_path, "-v"],
        stdin=subprocess.DEVNULL,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        encoding="utf-8",
    )

    assert result.returncode != 0
    assert result.stdout == ""


VILBOZ14_CONFIGS = [
    make_config("vilboz14", sku_id=0, frid_match="Google_Vilboz"),
    make_config("vilboz14", sku_id=1, frid_match="Google_Vilboz"),
    make_config(
        "vilboz14",
        sku_id=1,
        frid_match="Google_Vilboz",
        custom_label_tag="vilboz14len",
    ),
]


def test_vilboz14(tmp_path, executable_path):
    make_fake_sysroot(
        tmp_path,
        acpi_frid="Google_Vilboz.123",
        smbios_sku=1,
        vpd_values={"custom_label_tag": "vilboz14len"},
        configs=VILBOZ14_CONFIGS,
    )

    # pylint: disable=subprocess-run-check
    result = subprocess.run(
        [executable_path, "--sysroot", tmp_path, "-v"],
        check=True,
        stdin=subprocess.DEVNULL,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        encoding="utf-8",
    )

    assert getvars(result.stdout) == {
        "SKU": "1",
        "CONFIG_INDEX": "2",
        "FIRMWARE_MANIFEST_KEY": "vilboz14",
    }


TROGDOR_CONFIGS = [
    make_config("trogdor", frid_match="Google_Trogdor"),
    make_config("lazor", frid_match="Google_Lazor", sku_id=0),
    make_config("lazor", frid_match="Google_Lazor", sku_id=1),
    make_config("lazor", frid_match="Google_Lazor", sku_id=2),
    make_config("lazor", frid_match="Google_Lazor", sku_id=3),
    make_config(
        "limozeen", frid_match="Google_Lazor", sku_id=5, custom_label_tag=""
    ),
    make_config(
        "limozeen",
        frid_match="Google_Lazor",
        sku_id=6,
        custom_label_tag="lazorwl",
    ),
    make_config(
        "limozeen", frid_match="Google_Lazor", sku_id=6, custom_label_tag=""
    ),
    make_config("lazor", frid_match="Google_Lazor"),
]


@pytest.mark.parametrize("config_idx", list(range(len(TROGDOR_CONFIGS))))
def test_trogdor(tmp_path, executable_path, config_idx):
    cfg = TROGDOR_CONFIGS[config_idx]
    identity = cfg["identity"]

    vpd = {}
    custom_label_tag = identity.get("custom-label-tag")
    if custom_label_tag:
        vpd["whitelabel_tag"] = custom_label_tag

    make_fake_sysroot(
        tmp_path,
        fdt_frid=f"{identity['frid']}.123_456",
        fdt_sku=identity.get("sku-id"),
        vpd_values=vpd,
        configs=TROGDOR_CONFIGS,
    )

    result = subprocess.run(
        [executable_path, "--sysroot", tmp_path, "-v"],
        check=True,
        stdin=subprocess.DEVNULL,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        encoding="utf-8",
    )

    assert getvars(result.stdout) == {
        "SKU": str(identity.get("sku-id", "none")),
        "CONFIG_INDEX": str(config_idx),
        "FIRMWARE_MANIFEST_KEY": cfg["name"],
    }


def test_frid_missing(tmp_path, executable_path):
    # When FRID is not available via ACPI or FDT, but required by all
    # configs, this should be an error.
    make_fake_sysroot(
        tmp_path,
        configs=TROGDOR_CONFIGS,
    )

    # pylint: disable=subprocess-run-check
    result = subprocess.run(
        [executable_path, "--sysroot", tmp_path, "-v"],
        stdin=subprocess.DEVNULL,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        encoding="utf-8",
    )

    assert result.returncode != 0
    assert getvars(result.stdout) == {
        "SKU": "none",
        "CONFIG_INDEX": "unknown",
        "FIRMWARE_MANIFEST_KEY": "",
    }


def test_missing_identity_table(tmp_path, executable_path):
    # When identity.bin is missing, crosid should exit with an error.

    # pylint: disable=subprocess-run-check
    result = subprocess.run(
        [executable_path, "--sysroot", tmp_path],
        stdin=subprocess.DEVNULL,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        encoding="utf-8",
    )

    assert result.returncode != 0
    assert getvars(result.stdout) == {
        "SKU": "none",
        "CONFIG_INDEX": "unknown",
        "FIRMWARE_MANIFEST_KEY": "",
    }


@pytest.mark.parametrize(
    "contents",
    [
        b"",  # too small for header
        struct.pack("<LLL4x", 42, 0, 0),  # bad version
        struct.pack("<LLL4x", 0, 0, 1),  # too small for entries
    ],
)
def test_corrupted_identity_table(tmp_path, executable_path, contents):
    # When identity.bin is corrupted, crosid should exit with an error.
    identity_file = (
        tmp_path / "usr" / "share" / "chromeos-config" / "identity.bin"
    )
    identity_file.parent.mkdir(exist_ok=True, parents=True)
    identity_file.write_bytes(contents)

    # pylint: disable=subprocess-run-check
    result = subprocess.run(
        [executable_path, "--sysroot", tmp_path],
        stdin=subprocess.DEVNULL,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        encoding="utf-8",
    )

    assert result.returncode != 0
    assert getvars(result.stdout) == {
        "SKU": "none",
        "CONFIG_INDEX": "unknown",
        "FIRMWARE_MANIFEST_KEY": "",
    }


@pytest.mark.parametrize(
    "contents",
    [
        "",
        "\n",
        "sku\n",
        "sku-\n",
        "sku8z\n",
        "8\n",
        "SKU8\n",
    ],
)
def test_corrupted_sku_x86(tmp_path, executable_path, contents):
    # Test with a corrupted SKU file that we won't match a specific
    # SKU.
    make_fake_sysroot(
        tmp_path,
        acpi_frid="Google_Snappy.123",
        smbios_sku=0,
        vpd_values={
            "customization_id": "MORGAN-SNAPPY",
        },
        configs=REEF_CONFIGS,
    )

    sku_file = tmp_path / "sys" / "class" / "dmi" / "id" / "product_sku"
    sku_file.write_text(contents)

    result = subprocess.run(
        [executable_path, "--sysroot", tmp_path],
        check=True,
        stdin=subprocess.DEVNULL,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        encoding="utf-8",
    )

    assert getvars(result.stdout) == {
        "SKU": "none",
        "CONFIG_INDEX": "8",
        "FIRMWARE_MANIFEST_KEY": "snappy",
    }


@pytest.mark.parametrize(
    "contents",
    [
        b"",
        b"\x00",
        b"\x00\x00\x00\x00\x00",
    ],
)
def test_corrupted_sku_arm(tmp_path, executable_path, contents):
    # Test with a corrupted SKU file that we won't match a specific
    # SKU.
    make_fake_sysroot(
        tmp_path,
        fdt_frid="Google_Lazor.123",
        fdt_sku=0,
        configs=TROGDOR_CONFIGS,
    )

    sku_file = (
        tmp_path / "proc" / "device-tree" / "firmware" / "coreboot" / "sku-id"
    )
    sku_file.write_bytes(contents)

    result = subprocess.run(
        [executable_path, "--sysroot", tmp_path],
        check=True,
        stdin=subprocess.DEVNULL,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        encoding="utf-8",
    )

    assert getvars(result.stdout) == {
        "SKU": "none",
        "CONFIG_INDEX": "8",
        "FIRMWARE_MANIFEST_KEY": "lazor",
    }


@pytest.mark.parametrize(
    ["key", "expected_result"],
    [
        ("CONFIG_INDEX", "4"),
        ("SKU", "7"),
        ("FIRMWARE_MANIFEST_KEY", "alan"),
    ],
)
def test_filter_output(tmp_path, executable_path, key, expected_result):
    make_fake_sysroot(
        tmp_path,
        acpi_frid="Google_Snappy.123",
        smbios_sku=7,
        vpd_values={"customization_id": "DOLPHIN-ALAN"},
        configs=REEF_CONFIGS,
    )

    result = subprocess.run(
        [executable_path, "--sysroot", tmp_path, "-f", key],
        check=True,
        stdin=subprocess.DEVNULL,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        encoding="utf-8",
    )

    assert result.stdout == expected_result


def test_factory_override(tmp_path, executable_path):
    """Test that the --sku-id and --custom-label-tag flags work."""
    make_fake_sysroot(
        tmp_path,
        fdt_frid="Google_Lazor.123_456",
        fdt_sku=3,
        configs=TROGDOR_CONFIGS,
    )

    result = subprocess.run(
        [
            executable_path,
            "--sysroot",
            tmp_path,
            "-v",
            "--sku-id",
            "6",
            "--custom-label-tag",
            "lazorwl",
        ],
        check=True,
        stdin=subprocess.DEVNULL,
        stdout=subprocess.PIPE,
        encoding="utf-8",
    )

    assert getvars(result.stdout) == {
        "SKU": "6",
        "CONFIG_INDEX": "6",
        "FIRMWARE_MANIFEST_KEY": "limozeen",
    }