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

"""Tests for proto_utils."""

import unittest

from chromiumos.config.payload import config_bundle_pb2
from common import config_bundle_utils


class ConfigBundleUtilsTest(unittest.TestCase):
    """Tests for config_bundle_utils."""

    def test_find_program(self):
        """Test the find_program method."""
        empty = config_bundle_pb2.ConfigBundle()
        bundle = config_bundle_pb2.ConfigBundle()
        program = bundle.program_list.add()
        program.name = "TestProgram"
        program.id.value = "TestProgram"

        self.assertIsNone(
            config_bundle_utils.find_program(empty, "TestProgram")
        )
        self.assertEqual(
            config_bundle_utils.find_program(empty, "TestProgram", create=True),
            program,
        )
        self.assertEqual(
            config_bundle_utils.find_program(empty, "TestProgram"), program
        )

        self.assertEqual(
            config_bundle_utils.find_program(bundle, "TestProgram"), program
        )
        self.assertEqual(
            config_bundle_utils.find_program(bundle, "testprogram"), program
        )
        self.assertIsNone(
            config_bundle_utils.find_program(bundle, "does_not_exist")
        )

    def test_find_partner(self):
        """Test the find_partner method."""
        empty = config_bundle_pb2.ConfigBundle()
        bundle = config_bundle_pb2.ConfigBundle()
        partner = bundle.partner_list.add()
        partner.name = "TestPartner"
        partner.id.value = "TestPartner"

        self.assertIsNone(
            config_bundle_utils.find_partner(empty, "TestPartner")
        )
        self.assertEqual(
            config_bundle_utils.find_partner(empty, "TestPartner", create=True),
            partner,
        )

        # Now that we called with create=True, we should find it in the bundle
        self.assertEqual(
            config_bundle_utils.find_partner(empty, "TestPartner"), partner
        )

        self.assertEqual(
            config_bundle_utils.find_partner(bundle, "TestPartner"), partner
        )
        self.assertEqual(
            config_bundle_utils.find_partner(bundle, "testpartner"), partner
        )
        self.assertIsNone(
            config_bundle_utils.find_partner(bundle, "does_not_exist")
        )

    def test_find_component(self):
        """Test the find_component method."""
        empty = config_bundle_pb2.ConfigBundle()
        bundle = config_bundle_pb2.ConfigBundle()
        component = bundle.components.add()
        component.id.value = "TestComponent"

        self.assertIsNone(
            config_bundle_utils.find_component(empty, "TestComponent")
        )
        self.assertEqual(
            config_bundle_utils.find_component(
                empty, "TestComponent", create=True
            ),
            component,
        )

        # Now that we called with create=True, we should find it in the bundle
        self.assertEqual(
            config_bundle_utils.find_component(empty, "TestComponent"),
            component,
        )

        self.assertEqual(
            config_bundle_utils.find_component(bundle, "TestComponent"),
            component,
        )
        self.assertEqual(
            config_bundle_utils.find_component(bundle, "testcomponent"),
            component,
        )
        self.assertIsNone(
            config_bundle_utils.find_component(bundle, "does_not_exist")
        )

    def test_flatten_config(self):
        """Test flattening ConfigBundle"""

        # Build a dummy test bundle config
        bundle = config_bundle_pb2.ConfigBundle()

        program = bundle.program_list.add()
        program.name = "A Program"
        program.id.value = "a_program"

        partner_0 = bundle.partner_list.add()
        partner_0.name = "Partner 0"
        partner_0.id.value = "partner_0"

        partner_1 = bundle.partner_list.add()
        partner_1.name = "Partner 1"
        partner_1.id.value = "partner_1"

        hw_design = bundle.design_list.add()
        hw_design.name = "A Design"
        hw_design.id.value = "a_design"
        hw_design.program_id.MergeFrom(program.id)
        hw_design.odm_id.MergeFrom(partner_0.id)

        hw_design_config = hw_design.configs.add()
        hw_design_config.id.value = "a_design_config"

        sw_config = bundle.software_configs.add()
        sw_config.design_config_id.MergeFrom(hw_design_config.id)

        device_brand = bundle.device_brand_list.add()
        device_brand.brand_name = "A Brand"
        device_brand.id.value = "a_brand"
        device_brand.design_id.MergeFrom(hw_design.id)
        device_brand.oem_id.MergeFrom(partner_1.id)

        brand_config = bundle.brand_configs.add()
        brand_config.brand_id.MergeFrom(device_brand.id)

        # Flatten config bundle into a FlatConfigList
        flattened = config_bundle_utils.flatten_config(bundle)
        self.assertEqual(len(flattened.values), 1)

        # And verify that values were queried correctly
        flat_value = flattened.values[0]
        self.assertEqual(flat_value.program, program)
        self.assertEqual(flat_value.hw_design, hw_design)
        self.assertEqual(flat_value.odm, partner_0)
        self.assertEqual(flat_value.hw_design_config, hw_design_config)
        self.assertEqual(flat_value.device_brand, device_brand)
        self.assertEqual(flat_value.oem, partner_1)
        self.assertEqual(flat_value.brand_sw_config, brand_config)