# Copyright 2018 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 functions in `build_data`.
"""


import json
import mock
import os
import sys
import unittest

import common
from autotest_lib.site_utils.stable_images import build_data


# _OMAHA_TEST_DATA - File with JSON data to be used as test input to
#   `_make_omaha_versions()`.  In the file, the various items in the
#   `omaha_data` list are selected to capture various specific test
#   cases:
#     + Board with no "beta" channel.
#     + Board with "beta" and another channel.
#     + Board with only a "beta" channel.
#     + Board with no "chrome_version" entry.
#     + Obsolete board with "is_active" set to false.
# The JSON content of the file is a subset of an actual
# `omaha_status.json` file copied when the unit test was last
# updated.
#
# _EXPECTED_OMAHA_VERSIONS - The expected output produced by the
#   contents of _OMAHA_TEST_DATA.

_OMAHA_TEST_DATA = 'test_omaha_status.json'
_EXPECTED_OMAHA_VERSIONS = {
    'auron-paine': 'R55-8872.54.0',
    'gale': 'R55-8872.40.9',
    'kevin': 'R55-8872.64.0',
    'zako-freon': 'R41-6680.52.0'
}


class OmahaDataTests(unittest.TestCase):
    """Tests for the `get_omaha_version_map()` function."""

    @mock.patch.object(build_data, '_read_gs_json_data')
    def test_make_omaha_versions(self, mock_read_gs):
        """Test `get_omaha_version_map()` against one simple input.

        This is a trivial test that asserts that a single
        hard-coded input returns a correct hard-coded output.

        @param mock_read_gs  Mock created for `_read_gs_json_data()`.
        """
        module_dir = os.path.dirname(sys.modules[__name__].__file__)
        data_file_path = os.path.join(module_dir, _OMAHA_TEST_DATA)
        mock_read_gs.return_value = json.load(open(data_file_path, 'r'))
        omaha_versions = build_data.get_omaha_version_map()
        self.assertEqual(omaha_versions, _EXPECTED_OMAHA_VERSIONS)


class KeyPathTests(unittest.TestCase):
    """Tests for the `_get_by_key_path()` function."""

    DICTDICT = {'level0': 'OK', 'level1_a': {'level1_b': 'OK'}}

    def _get_by_key_path(self, keypath):
        get_by_key_path = build_data._get_by_key_path
        return get_by_key_path(self.DICTDICT, keypath)

    def _check_path_valid(self, keypath):
        self.assertEqual(self._get_by_key_path(keypath), 'OK')

    def _check_path_invalid(self, keypath):
        self.assertIsNone(self._get_by_key_path(keypath))

    def test_one_element(self):
        """Test a single-element key path with a valid key."""
        self._check_path_valid(['level0'])

    def test_two_element(self):
        """Test a two-element key path with a valid key."""
        self._check_path_valid(['level1_a', 'level1_b'])

    def test_one_element_invalid(self):
        """Test a single-element key path with an invalid key."""
        self._check_path_invalid(['absent'])

    def test_two_element_invalid(self):
        """Test a two-element key path with an invalid key."""
        self._check_path_invalid(['level1_a', 'absent'])


class GetOmahaUpgradeTests(unittest.TestCase):
    """Tests for `get_omaha_upgrade()`."""

    V0 = 'R66-10452.27.0'
    V1 = 'R66-10452.30.0'
    V2 = 'R67-10494.0.0'

    def test_choose_cros_version(self):
        """Test that the CrOS version is chosen when it is later."""
        new_version = build_data.get_omaha_upgrade(
            {'board': self.V0}, 'board', self.V1)
        self.assertEquals(new_version, self.V1)

    def test_choose_omaha_version(self):
        """Test that the Omaha version is chosen when it is later."""
        new_version = build_data.get_omaha_upgrade(
            {'board': self.V1}, 'board', self.V0)
        self.assertEquals(new_version, self.V1)

    def test_branch_version_comparison(self):
        """Test that versions on different branches compare properly."""
        new_version = build_data.get_omaha_upgrade(
            {'board': self.V1}, 'board', self.V2)
        self.assertEquals(new_version, self.V2)

    def test_identical_versions(self):
        """Test handling when both the versions are the same."""
        new_version = build_data.get_omaha_upgrade(
            {'board': self.V1}, 'board', self.V1)
        self.assertEquals(new_version, self.V1)

    def test_board_name_mapping(self):
        """Test that AFE board names are mapped to Omaha board names."""
        board_equivalents = [
            ('a-b', 'a-b'), ('c_d', 'c-d'),
            ('e_f-g', 'e-f-g'), ('hi', 'hi')
        ]
        for afe_board, omaha_board in board_equivalents:
            new_version = build_data.get_omaha_upgrade(
                {omaha_board: self.V1}, afe_board, self.V0)
            self.assertEquals(new_version, self.V1)

    def test_no_omaha_version(self):
        """Test handling when there's no Omaha version."""
        new_version = build_data.get_omaha_upgrade(
            {}, 'board', self.V1)
        self.assertEquals(new_version, self.V1)

    def test_no_afe_version(self):
        """Test handling when there's no CrOS version."""
        new_version = build_data.get_omaha_upgrade(
            {'board': self.V1}, 'board', None)
        self.assertEquals(new_version, self.V1)

    def test_no_version_whatsoever(self):
        """Test handling when both versions are `None`."""
        new_version = build_data.get_omaha_upgrade(
            {}, 'board', None)
        self.assertIsNone(new_version)


class GetFirmwareVersionsTests(unittest.TestCase):
    """Tests for get_firmware_versions."""

    def setUp(self):
        self.cros_version = 'R64-10176.65.0'

    @mock.patch.object(build_data, '_read_gs_json_data')
    def test_get_firmware_versions_on_normal_build(self, mock_read_gs):
        """Test get_firmware_versions on normal build."""
        metadata_json = """
{
    "unibuild": false,
    "board-metadata":{
        "auron_paine":{
             "main-firmware-version":"Google_Auron_paine.6301.58.98"
        }
   }
}
        """
        mock_read_gs.return_value = json.loads(metadata_json)
        board = 'auron_paine'

        fw_version = build_data.get_firmware_versions(
                board, self.cros_version)
        expected_version = {board: "Google_Auron_paine.6301.58.98"}
        self.assertEqual(fw_version, expected_version)

    @mock.patch.object(build_data, '_read_gs_json_data',
                       side_effect = Exception('GS ERROR'))
    def test_get_firmware_versions_with_exceptions(self, mock_read_gs):
        """Test get_firmware_versions on normal build with exceptions."""
        afe_mock = mock.Mock()
        fw_version = build_data.get_firmware_versions(
                'auron_paine', self.cros_version)
        self.assertEqual(fw_version, {'auron_paine': None})

    @mock.patch.object(build_data, '_read_gs_json_data')
    def test_get_firmware_versions_on_unibuild(self, mock_read_gs):
        """Test get_firmware_version on uni-build."""
        metadata_json = """
{
    "unibuild": true,
    "board-metadata":{
        "coral":{
            "kernel-version":"4.4.114-r1354",
            "models":{
                "blue":{
                    "main-readonly-firmware-version":"Google_Coral.10068.37.0",
                    "main-readwrite-firmware-version":"Google_Coral.10068.39.0"
                },
                "robo360":{
                    "main-readonly-firmware-version":"Google_Coral.10068.34.0",
                    "main-readwrite-firmware-version":null
                },
                "porbeagle":{
                    "main-readonly-firmware-version":null,
                    "main-readwrite-firmware-version":null
                }
            }
        }
    }
}
"""
        mock_read_gs.return_value = json.loads(metadata_json)
        fw_version = build_data.get_firmware_versions(
            'coral', self.cros_version)
        expected_version = {
            'blue': 'Google_Coral.10068.39.0',
            'robo360': 'Google_Coral.10068.34.0',
            'porbeagle': None
        }
        self.assertEqual(fw_version, expected_version)

    @mock.patch.object(build_data, '_read_gs_json_data')
    def test_get_firmware_versions_on_unibuild_no_models(self, mock_read_gs):
        """Test get_firmware_versions on uni-build without models dict."""
        metadata_json = """
{
    "unibuild": true,
    "board-metadata":{
        "coral":{
            "kernel-version":"4.4.114-r1354"
        }
    }
}
"""
        mock_read_gs.return_value = json.loads(metadata_json)
        fw_version = build_data.get_firmware_versions(
                'coral', self.cros_version)
        self.assertEqual(fw_version, {'coral': None})


if __name__ == '__main__':
    unittest.main()