# 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 for Hwid merging plugin"""

import unittest

from chromiumos.config.api.component_pb2 import Component
from chromiumos.config.payload.config_bundle_pb2 import ConfigBundle
from .merge_hwid import _set_support_status, MergeHwid


def _mock_hwid_component(type_name, label, values):
  return {
      'components': {
          type_name: {
              'items': {
                  label: {
                      'values': values
                  },
              },
          },
      },
  }


class MergeHWidTests(unittest.TestCase):
  """Tests for MergeHwid plugin."""

  # pylint: disable=too-many-public-methods

  def test_support_status(self):
    """Test the _set_support_status functionality."""
    bundle = ConfigBundle()

    # With no status information, our support status should be unknown.
    component = bundle.components.add()
    component = _set_support_status(component, {})
    self.assertEqual(
        component.support_status,
        component.SupportStatus.STATUS_UNKNOWN,
    )

    # A known status should get reflected into component.
    component = bundle.components.add()
    component = _set_support_status(component, {'status': 'supported'})
    self.assertEqual(
        component.support_status,
        component.SupportStatus.STATUS_SUPPORTED,
    )

    # An unknown status value should _not_ get reflected into component.
    component = bundle.components.add()
    component = _set_support_status(component, {'status': 'fooble'})
    self.assertEqual(
        component.support_status,
        component.SupportStatus.STATUS_UNKNOWN,
    )

  def test_audio_codec(self):
    """Test basic audio codec functionality."""
    test_label = 'ACLABEL123'
    test_name = 'ACLABEL:123'

    hwid = _mock_hwid_component(
        'audio_codec',
        test_label,
        {'name': test_name},
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'audio_codec')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.id.value, test_label)
    self.assertEqual(component.name, test_name)
    self.assertEqual(component.audio_codec.name, test_name)

    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})

  def test_battery(self):
    """Test basic battery functionality."""
    test_label = 'battery123'
    test_oem = 'conglomo'
    test_model = 'battery-123-abc'
    test_tech = 'li-poly'

    hwid = _mock_hwid_component(
        'battery',
        test_label,
        {
            'manufacturer': test_oem,
            'model_name': test_model,
            'technology': test_tech,
        },
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'battery')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.id.value, test_label)
    self.assertEqual(component.manufacturer_id.value, test_oem)
    self.assertEqual(component.battery.model, test_model)
    self.assertEqual(component.battery.technology, Component.Battery.LI_POLY)

    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})

  def test_bluetooth(self):
    """Test basic bluetooth functionality."""
    test_label = 'bluetooth123'
    test_vendor = 'vendor'
    test_product = 'product'
    test_bcd = 'bcd'

    hwid = _mock_hwid_component(
        'bluetooth',
        test_label,
        {
            'idVendor': test_vendor,
            'idProduct': test_product,
            'bcdDevice': test_bcd,
        },
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'bluetooth')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.id.value, test_label)
    self.assertEqual(component.bluetooth.usb.vendor_id, test_vendor)
    self.assertEqual(component.bluetooth.usb.product_id, test_product)
    self.assertEqual(component.bluetooth.usb.bcd_device, test_bcd)

    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})

  def test_cellular(self):
    """Test basic cellular functionality."""
    test_label = 'cellular123'
    test_vendor = 'vendor'
    test_product = 'product'
    test_bcd = 'bcd'

    hwid = _mock_hwid_component(
        'cellular',
        test_label,
        {
            'idVendor': test_vendor,
            'idProduct': test_product,
            'bcdDevice': test_bcd,
        },
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'cellular')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.id.value, test_label)
    self.assertEqual(component.cellular.usb.vendor_id, test_vendor)
    self.assertEqual(component.cellular.usb.product_id, test_product)
    self.assertEqual(component.cellular.usb.bcd_device, test_bcd)

    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})

  def test_cpu(self):
    """Test basic cpu functionality."""
    test_label = 'some_cpu_123'
    test_model = 'intel i3-5005U'
    test_cores = 4

    hwid = _mock_hwid_component(
        'cpu',
        test_label,
        {
            'model': test_model,
            'cores': test_cores,
        },
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'cpu')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.id.value, test_label)
    self.assertEqual(component.soc.family.arch, component.soc.X86_64)
    self.assertEqual(component.soc.cores, 4)
    self.assertEqual(component.soc.family.name, 'I3-5005U')

    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})

  def test_cpu_nocores(self):
    """Test cpu entry without cores field."""
    test_label = 'some_cpu_123'
    test_model = 'intel i3-5005U'

    hwid = _mock_hwid_component(
        'cpu',
        test_label,
        {
            'model': test_model,
        },
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'cpu')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.id.value, test_label)
    self.assertEqual(component.soc.cores, 0)

    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})

  def test_display_panel(self):
    """Test basic display panel functionality."""
    test_label = 'some_cpu_123'
    test_vendor = 'ABCCo'
    test_product_id = 'panel_1a_niner'
    test_width = 800
    test_height = 480

    hwid = _mock_hwid_component(
        'display_panel',
        test_label,
        {
            'vendor': test_vendor,
            'product_id': test_product_id,
            'width': test_width,
            'height': test_height,
        },
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'display_panel')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.id.value, test_label)
    self.assertEqual(component.manufacturer_id.value, test_vendor)
    self.assertEqual(component.display_panel.product_id, test_product_id)
    self.assertEqual(component.display_panel.properties.width_px, test_width)
    self.assertEqual(component.display_panel.properties.height_px, test_height)

    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})

  def test_dram(self):
    """Test basic display panel functionality."""
    test_label = 'some_dram_123abc_0'
    test_part = '1234abcd'
    test_size = 2048

    test_timings = [
        ('LPDDR4', Component.Memory.LP_DDR4),
        ('LPDDR3', Component.Memory.LP_DDR3),
        ('DDR4', Component.Memory.DDR4),
        ('DDR3', Component.Memory.DDR3),
        ('DDR2', Component.Memory.DDR2),
        ('DDR', Component.Memory.DDR),
    ]

    for memory_timing, memory_type in test_timings:
      hwid = _mock_hwid_component(
          'dram',
          test_label,
          {
              'part': test_part,
              'size': str(test_size),
              'timing': memory_timing
          },
      )

      bundle = ConfigBundle()
      merger = MergeHwid(hwid_data=hwid)
      merger.merge(bundle)

      self.assertEqual(len(bundle.components), 1)
      component = bundle.components[0]
      self.assertEqual(component.hwid_type, 'dram')
      self.assertEqual(component.hwid_label, test_label)
      self.assertEqual(component.id.value, test_label)
      self.assertEqual(component.memory.part_number, test_part)
      self.assertEqual(component.memory.profile.size_megabytes, test_size)
      self.assertEqual(component.memory.profile.type, memory_type)

      # Should be nothing unparsed
      self.assertEqual(merger.residual(), {})

  def test_ec_flash(self):
    """Test basic ec_flash functionality."""
    test_label = 'some_flash_chip_123abc'
    test_part = '1234abcd'
    test_vendor = 'TestVendorCo'

    hwid = _mock_hwid_component(
        'ec_flash_chip',
        test_label,
        {
            'name': test_part,
            'vendor': test_vendor
        },
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'ec_flash_chip')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.ec_flash_chip.part_number, test_part)
    self.assertEqual(component.manufacturer_id.value, test_vendor)

    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})

  def test_ec(self):
    """Test basic ec functionality."""
    test_label = 'some_ec_123abc'
    test_part = '1234abcd'
    test_vendor = 'TestVendorCo'

    hwid = _mock_hwid_component(
        'embedded_controller',
        test_label,
        {
            'name': test_part,
            'vendor': test_vendor
        },
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'embedded_controller')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.ec.part_number, test_part)
    self.assertEqual(component.manufacturer_id.value, test_vendor)

    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})

  def test_flash(self):
    """Test basic flash functionality."""
    test_label = 'some_flash_123abc'
    test_part = '1234abcd'
    test_vendor = 'TestVendorCo'

    hwid = _mock_hwid_component(
        'flash_chip',
        test_label,
        {
            'name': test_part,
            'vendor': test_vendor
        },
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'flash_chip')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.system_flash_chip.part_number, test_part)
    self.assertEqual(component.manufacturer_id.value, test_vendor)

    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})

  def test_storage(self):
    """Test basic storage functionality."""
    test_label = 'some_storage_123abc'
    test_emmc5 = '1.2.3'
    test_manfid = 'manfid'
    test_name = 'Name'
    test_oemid = 'oemid'
    test_prv = 'prv'
    test_sectors = 'sectors'
    test_type = 'MMC'

    hwid = _mock_hwid_component(
        'storage',
        test_label,
        {
            'emmc5_fw_ver': test_emmc5,
            'manfid': test_manfid,
            'name': test_name,
            'oemid': test_oemid,
            'prv': test_prv,
            'sectors': test_sectors,
            'type': test_type,
        },
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'storage')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.storage.emmc5_fw_ver, test_emmc5)
    self.assertEqual(component.storage.manfid, test_manfid)
    self.assertEqual(component.storage.name, test_name)
    self.assertEqual(component.storage.oemid, test_oemid)
    self.assertEqual(component.storage.prv, test_prv)
    self.assertEqual(component.storage.sectors, test_sectors)
    self.assertEqual(component.storage.type, Component.Storage.EMMC)

    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})

  def test_stylus_i2c(self):
    """Test stylus I2C functionality."""
    test_label = 'some_touch_123abc'
    test_vendor = '0x1234'
    test_product = '0xbeef'

    hwid = _mock_hwid_component(
        'stylus',
        test_label,
        {
            'vendor': test_vendor,
            'product': test_product,
        },
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'stylus')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.stylus.i2c.product, test_product)
    self.assertEqual(component.stylus.i2c.vendor, test_vendor)

    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})

  def test_stylus_usb(self):
    """Test stylus USB functionality."""
    test_label = 'some_touch_123abc'
    test_vendorid = '0x1234'
    test_productid = '0xbeef'
    test_bcd_device = 'bcd'

    hwid = _mock_hwid_component(
        'stylus',
        test_label,
        {
            'vendor_id': test_vendorid,
            'product_id': test_productid,
            'bcd_device': test_bcd_device,
        },
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'stylus')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.stylus.usb.product_id, test_productid)
    self.assertEqual(component.stylus.usb.vendor_id, test_vendorid)
    self.assertEqual(component.stylus.usb.bcd_device, test_bcd_device)

    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})

  def test_touchpad_usb(self):
    """Test touchpad USB functionality."""
    test_label = 'some_touchpad_123abc'
    test_product = 'product'
    test_vendor = 'vendor'

    hwid = _mock_hwid_component(
        'touchpad',
        test_label,
        {
            'product': test_product,
            'vendor': test_vendor,
        },
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'touchpad')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.touchpad.type, Component.Touch.USB)
    self.assertEqual(component.touchpad.usb.product_id, test_product)
    self.assertEqual(component.touchpad.usb.vendor_id, test_vendor)

    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})

  def test_touchpad_i2c(self):
    """Test touchpad I2C functionality."""
    test_label = 'some_touchpad_123abc'
    test_fw_version = '1.2.3'
    test_fw_csum = 'csum'

    hwid = _mock_hwid_component(
        'touchpad',
        test_label,
        {
            'fw_version': test_fw_version,
            'fw_csum': test_fw_csum
        },
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'touchpad')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.touchpad.type, Component.Touch.I2C)
    self.assertEqual(component.touchpad.fw_version, test_fw_version)
    self.assertEqual(component.touchpad.fw_checksum, test_fw_csum)

    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})

  def test_tpm(self):
    """Test tpm functionality."""
    test_label = 'some_tpm_123abc'
    test_mfg_info = 'TPMCo'
    test_version = '1.2.3'

    hwid = _mock_hwid_component(
        'tpm',
        test_label,
        {
            'manufacturer_info': test_mfg_info,
            'version': test_version
        },
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'tpm')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.tpm.manufacturer_info, test_mfg_info)
    self.assertEqual(component.tpm.version, test_version)

    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})

  def test_touchscreen(self):
    """Test touchscreen functionality."""
    test_label = 'some_touch_123abc'
    test_vendor = '0x1234'
    test_product = '0xbeef'

    hwid = _mock_hwid_component(
        'touchscreen',
        test_label,
        {
            'vendor': test_vendor,
            'product': test_product,
        },
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'touchscreen')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.touchscreen.usb.product_id, test_product)
    self.assertEqual(component.touchscreen.usb.vendor_id, test_vendor)
    self.assertEqual(component.touchscreen.type, Component.Touch.USB)

    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})

  def test_usb_hosts(self):
    """Test USB hosts functionality."""
    test_label = 'some_touch_123abc'
    test_mfg = 'ChipCo'
    test_device = '0x1234'
    test_vendor = '0xabcd'
    test_revision = '123'

    hwid = _mock_hwid_component(
        'usb_hosts',
        test_label,
        {
            'manufacturer': test_mfg,
            'device': test_device,
            'vendor': test_vendor,
            'revision_id': test_revision
        },
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'usb_hosts')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.manufacturer_id.value, test_mfg)
    self.assertEqual(component.usb_host.product_id, test_device)
    self.assertEqual(component.usb_host.vendor_id, test_vendor)

    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})

  def test_video_usb(self):
    """Test USB video functionality."""
    test_label = 'some_touch_123abc'
    test_product = '0x1234'
    test_vendor = '0xabcd'
    test_bcd = '12'

    hwid = _mock_hwid_component(
        'video',
        test_label,
        {
            'bus_type': 'usb',
            'idProduct': test_product,
            'idVendor': test_vendor,
            'bcdDevice': test_bcd
        },
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'video')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.camera.usb.product_id, test_product)
    self.assertEqual(component.camera.usb.vendor_id, test_vendor)
    self.assertEqual(component.camera.usb.bcd_device, test_bcd)

    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})

  def test_video_pci(self):
    """Test PCI video functionality."""
    test_label = 'some_touch_123abc'
    test_vendor = '0xabcd'
    test_device = '0x1234'
    test_revision = '12'

    hwid = _mock_hwid_component(
        'video',
        test_label,
        {
            'bus_type': 'pci',
            'vendor': test_vendor,
            'device': test_device,
            'revision_id': test_revision
        },
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'video')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.camera.pci.vendor_id, test_vendor)
    self.assertEqual(component.camera.pci.device_id, test_device)
    self.assertEqual(component.camera.pci.revision_id, test_revision)

    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})

  def test_wireless(self):
    """Test wireless functionality."""
    test_label = 'some_touch_123abc'
    test_vendor = '0xabcd'
    test_device = '0x1234'
    test_revision = '12'

    hwid = _mock_hwid_component(
        'wireless',
        test_label,
        {
            'vendor': test_vendor,
            'device': test_device,
            'revision_id': test_revision
        },
    )

    bundle = ConfigBundle()
    merger = MergeHwid(hwid_data=hwid)
    merger.merge(bundle)

    self.assertEqual(len(bundle.components), 1)
    component = bundle.components[0]
    self.assertEqual(component.hwid_type, 'wireless')
    self.assertEqual(component.hwid_label, test_label)
    self.assertEqual(component.wifi.pci.vendor_id, test_vendor)
    self.assertEqual(component.wifi.pci.device_id, test_device)
    self.assertEqual(component.wifi.pci.revision_id, test_revision)
    # Should be nothing unparsed
    self.assertEqual(merger.residual(), {})