#!/usr/bin/python2
# pylint: disable-msg=C0111
#
# Copyright 2019 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
"""Test for skylab json utils."""

from __future__ import unicode_literals

import unittest

import common
#TODO(gregorynisbet): remove renamed import of skylab_json_utils
from autotest_lib.cli import skylab_json_utils as sky
from autotest_lib.cli import skylab_json_utils

basic_labels = sky.Labels()
basic_labels._add_label("key1:value1")
basic_labels._add_label("key2")
basic_labels._add_label("key4")
basic_labels._add_label("key6")


class skylab_json_utils_unittest(unittest.TestCase):
    def test_label_empty(self):
        self.assertFalse(sky.Labels().bools)
        self.assertFalse(sky.Labels().strings)
        self.assertFalse(sky.Labels())

    def test_label_copy(self):
        basic_labels2 = sky.Labels(basic_labels)
        self.assertEqual(basic_labels, basic_labels2)

    def test_bool_label_present(self):
        self.assertTrue(basic_labels.get_bool("key2"))

    def test_bool_label_absent(self):
        self.assertFalse(basic_labels.get_bool("nonexistent-key"))

    def test_string_label_present(self):
        self.assertEqual(basic_labels.get_string("key1"), "value1")

    def test_string_label_absent(self):
        self.assertIsNone(basic_labels.get_string("nonexistent-key"))

    def test_enum_label_present(self):
        """the value in a key:value pair into a string that resembles a

        protobuf constant.

        The skylab add-dut JSON API expects certain fields which are
        protobuf enums to be strings of this form.
    """
        self.assertEqual(
            basic_labels.get_enum("key1", prefix="PREFIX_"), "PREFIX_VALUE1")

    def test_enum_label_absent(self):
        """by convention, many of the 'zero values' protobuf constants

    are named TYPE_INVALID.

        e.g. 'CARRIER_INVALID'
    """
        self.assertEqual(
            basic_labels.get_enum("nonexistent-key", prefix="THING_"),
            "THING_INVALID")

    def test_bool_keys_starting_with(self):
        self.assertEqual(
            set(basic_labels.bool_keys_starting_with("k")),
            {"key2", "key4", "key6"})

    def test_arc_present(self):
        l = sky.Labels()
        l._add_label("arc")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["arc"], True)

    def test_arc_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["arc"], False)

    def test_board_present(self):
        l = sky.Labels()
        l._add_label("board:nami")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["board"], "nami")

    def test_board_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["board"], None)

    def test_cr50phase_present(self):
        l = sky.Labels()
        l._add_label("cr50:0.3.18")
        out = sky.process_labels(l, platform=None)
        # TODO(gregorynisbet): note! strictly speaking this is wrong,
        # but skylab does not support version numbers in the CR50_PHASE
        self.assertEqual(out["cr50Phase"], "CR50_PHASE_INVALID")

    def test_cr50phase_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["cr50Phase"], "CR50_PHASE_INVALID")

    def test_board_present(self):
        l = sky.Labels()
        l._add_label("model:syndra")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["model"], "syndra")

    def test_board_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["model"], None)

    def test_platform(self):
        l = None
        out = sky.process_labels(None, platform=47)
        self.assertEqual(out["platform"], 47)

    def test_reference_design_present(self):
        l = sky.Labels()
        l._add_label("reference_design:Google_Nami")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["referenceDesign"], "Google_Nami")

    def test_reference_design_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["referenceDesign"], None)

    def test_ec_present(self):
        l = sky.Labels()
        l._add_label("ec:cros")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["ecType"], "EC_TYPE_CHROME_OS")

    def test_ec_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["ecType"], "EC_TYPE_INVALID")

    def test_os_present(self):
        l = sky.Labels()
        l._add_label("os:cros")
        out = sky.process_labels(l, platform=None)
        # NOTE: the type is OS_TYPE_CROS not OS_TYPE_CHROME_OS
        self.assertEqual(out["osType"], "OS_TYPE_CROS")

    def test_os_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["osType"], "OS_TYPE_INVALID")

    def test_critical_pool_present(self):
        l = sky.Labels()
        # note: use suites rather than another pool because
        # suites will always be mapped to DUT_POOL_SUITES
        l._add_label("pool:suites")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["criticalPools"], ["DUT_POOL_SUITES"])

    def test_critical_pool_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertFalse("criticalPools" in out)
    
    def test_hwid_sku_present(self):
        l = sky.Labels()
        l._add_label("sku:TEST")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["hwidSku"], "TEST")
    
    def test_hwid_sku_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["hwidSku"], None)

    def test_cts_abi_present(self):
        l = sky.Labels()
        l._add_label("cts_abi_arm")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["ctsAbi"], ["CTS_ABI_ARM"])

    def test_cts_abi_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["ctsAbi"], [])

    def test_cts_cpu_present(self):
        l = sky.Labels()
        l._add_label("cts_cpu_arm")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["ctsCpu"], ["CTS_CPU_ARM"])

    def test_cts_cpu_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["ctsCpu"], [])

    def test_atrus_present(self):
        l = sky.Labels()
        l._add_label("atrus")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["atrus"], True)

    def test_atrus_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["atrus"], False)

    def test_bluetooth_present(self):
        l = sky.Labels()
        l._add_label("bluetooth")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["bluetooth"], True)

    def test_bluetooth_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["bluetooth"], False)

    def test_detachablebase_present(self):
        l = sky.Labels()
        l._add_label("detachablebase")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["detachablebase"], True)

    def test_detachablebase_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["detachablebase"], False)

    def test_flashrom_present(self):
        l = sky.Labels()
        l._add_label("flashrom")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["flashrom"], True)

    def test_flashrom_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["flashrom"], False)

    def test_hotwording_present(self):
        l = sky.Labels()
        l._add_label("hotwording")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["hotwording"], True)

    def test_hotwording_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["hotwording"], False)

    def test_internal_display_present(self):
        l = sky.Labels()
        l._add_label("internal_display")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["internalDisplay"], True)

    def test_internal_display_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["internalDisplay"], False)

    def test_lucidsleep_present(self):
        l = sky.Labels()
        l._add_label("lucidsleep")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["lucidsleep"], True)

    def test_lucidsleep_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["lucidsleep"], False)

    def test_touchpad_present(self):
        l = sky.Labels()
        l._add_label("touchpad")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["touchpad"], True)

    def test_touchpad_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["touchpad"], False)

    def test_webcam_present(self):
        l = sky.Labels()
        l._add_label("webcam")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["webcam"], True)

    def test_webcam_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["webcam"], False)

    def test_graphics_present(self):
        l = sky.Labels()
        l._add_label("graphics:graphicsval")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["graphics"], "graphicsval")

    def test_graphics_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["graphics"], None)

    def test_gpu_family(self):
        l = sky.Labels()
        l._add_label("gpu_family:gpu_family_val")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["gpuFamily"], "gpu_family_val")

    def test_graphics_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["gpuFamily"], None)

    def test_modem_present(self):
        l = sky.Labels()
        l._add_label("modem:gobi2k")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["modem"], "gobi2k")

    def test_modem_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["modem"], "")

    def test_power_present(self):
        l = sky.Labels()
        l._add_label("power:battery")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["power"], "battery")

    def test_power_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["power"], None)

    def test_storage_present(self):
        l = sky.Labels()
        l._add_label("storage:nmve")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["storage"], "nmve")

    def test_storage_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertIsNone(out["capabilities"]["storage"])

    def test_telephony_present(self):
        l = sky.Labels()
        l._add_label("telephony:volte")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["telephony"], "volte")

    def test_telephony_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["telephony"], "")

    def test_carrier_present(self):
        l = sky.Labels()
        l._add_label("carrier:att")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["carrier"], "CARRIER_ATT")

    def test_carrier_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["carrier"], "CARRIER_INVALID")

    def test_video_accleration_present(self):
        l = sky.Labels()
        l._add_label("hw_video_acc_enc_vp9")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["videoAcceleration"], ["VIDEO_ACCELERATION_ENC_VP9"])

    def test_video_accleration_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["capabilities"]["videoAcceleration"], [])

    def test_audio_board_present(self):
        l = sky.Labels()
        l._add_label("audio_board")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["audioBoard"], True)

    def test_audio_board_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["audioBoard"], False)

    def test_audio_box_present(self):
        l = sky.Labels()
        l._add_label("audio_box")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["audioBox"], True)

    def test_audio_box_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["audioBox"], False)

    def test_audio_loopback_dongle_present(self):
        l = sky.Labels()
        l._add_label("audio_loopback_dongle")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["audioLoopbackDongle"], True)

    def test_audio_loopback_dongle_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["audioLoopbackDongle"], False)

    def test_chameleon_present(self):
        l = sky.Labels()
        l._add_label("chameleon")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["chameleon"], True)

    def test_chameleon_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["chameleon"], False)

    def test_chameleon_type_present(self):
        l = sky.Labels()
        # the chameleon type field is named chameleon:something
        # NOT chameleon_type:something
        l._add_label("chameleon:hdmi")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["chameleonType"],
                         "CHAMELEON_TYPE_HDMI")

    def test_chameleon_type_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertIsNone(out["peripherals"]["chameleonType"])

    def test_conductive_present(self):
        l = sky.Labels()
        l._add_label("conductive:True")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["conductive"], True)

    def test_conductive_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["conductive"], False)

    def test_conductive_false(self):
        l = sky.Labels()
        l._add_label("conductive:False")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["conductive"], False)

    def test_huddly_present(self):
        l = sky.Labels()
        l._add_label("huddly")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["huddly"], True)

    def test_huddly_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["huddly"], False)

    def test_mimo_present(self):
        l = sky.Labels()
        l._add_label("mimo")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["mimo"], True)

    def test_mimo_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["mimo"], False)

    def test_servo_present(self):
        l = sky.Labels()
        l._add_label("servo")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["servo"], True)

    def test_servo_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["servo"], False)

    def test_stylus_present(self):
        l = sky.Labels()
        l._add_label("stylus")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["stylus"], True)

    def test_stylus_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["stylus"], False)

    def test_wificell_present(self):
        l = sky.Labels()
        l._add_label("pool:bvt")
        l._add_label("wificell")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["wificell"], True)

    def test_wificell_absent(self):
        l = sky.Labels()
        l._add_label("pool:bvt")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["peripherals"]["wificell"], False)

    def test_chaos_dut_present(self):
        l = sky.Labels()
        l._add_label("chaos_dut")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["testCoverageHints"]["chaosDut"], True)

    def test_chaos_dut_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["testCoverageHints"]["chaosDut"], False)

    def test_chaos_dut_present(self):
        l = sky.Labels()
        l._add_label("chaos_dut")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["testCoverageHints"]["chaosDut"], True)

    def test_chaos_dut_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["testCoverageHints"]["chaosDut"], False)

    def test_chromesign_present(self):
        l = sky.Labels()
        l._add_label("chromesign")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["testCoverageHints"]["chromesign"], True)

    def test_chromesign_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["testCoverageHints"]["chromesign"], False)

    def test_hangout_app_present(self):
        l = sky.Labels()
        l._add_label("hangout_app")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["testCoverageHints"]["hangoutApp"], True)

    def test_hangout_app_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["testCoverageHints"]["hangoutApp"], False)

    def test_meet_app_present(self):
        l = sky.Labels()
        l._add_label("meet_app")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["testCoverageHints"]["meetApp"], True)

    def test_meet_app_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["testCoverageHints"]["meetApp"], False)

    def test_recovery_test_present(self):
        l = sky.Labels()
        l._add_label("recovery_test")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["testCoverageHints"]["recoveryTest"], True)

    def test_recovery_test_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["testCoverageHints"]["recoveryTest"], False)

    def test_test_audio_jack_present(self):
        # NOTE: test_audio_jack maps to testAudiojack
        # instead of the expected *testAudioJack
        l = sky.Labels()
        l._add_label("test_audio_jack")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["testCoverageHints"]["testAudiojack"], True)

    def test_test_audio_jack_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["testCoverageHints"]["testAudiojack"], False)

    def test_test_hdmiaudio_present(self):
        l = sky.Labels()
        l._add_label("test_hdmiaudio")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["testCoverageHints"]["testHdmiaudio"], True)

    def test_test_hdmiaudio_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["testCoverageHints"]["testHdmiaudio"], False)

    def test_test_usbprinting_present(self):
        l = sky.Labels()
        l._add_label("test_usbprinting")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["testCoverageHints"]["testUsbprinting"], True)

    def test_test_usbprinting_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["testCoverageHints"]["testUsbprinting"], False)

    def test_usb_detect_present(self):
        l = sky.Labels()
        l._add_label("usb_detect")
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["testCoverageHints"]["usbDetect"], True)

    def test_usb_detect_absent(self):
        l = sky.Labels()
        out = sky.process_labels(l, platform=None)
        self.assertEqual(out["testCoverageHints"]["usbDetect"], False)

    def test_validate_fields_smoke_test(self):
        with self.assertRaises(ValueError):
            skylab_json_utils.validate_required_fields_for_skylab(47)

    def test_validate_fields_no_common(self):
        with self.assertRaises(ValueError):
            skylab_json_utils.validate_required_fields_for_skylab({})

    def test_validate_fields_no_labels(self):
        with self.assertRaises(ValueError):
            skylab_json_utils.validate_required_fields_for_skylab(
                {"common": None})

    def test_validate_fields_no_board(self):
        with self.assertRaises(
                skylab_json_utils.SkylabMissingLabelException) as ctx:
            skylab_json_utils.validate_required_fields_for_skylab(
                {"common": {
                    "labels": []
                }})
        e = ctx.exception
        self.assertEqual(e.message, "board")

    def test_validate_fields_no_model(self):
        with self.assertRaises(
                skylab_json_utils.SkylabMissingLabelException) as ctx:
            skylab_json_utils.validate_required_fields_for_skylab(
                {"common": {
                    "labels": {
                        "board": True
                    }
                }})
        e = ctx.exception
        self.assertEqual(e.message, "model")

    def test_validate_fields_no_sku(self):
        with self.assertRaises(
                skylab_json_utils.SkylabMissingLabelException) as ctx:
            skylab_json_utils.validate_required_fields_for_skylab(
                {"common": {
                    "labels": {
                        "board": True,
                        "model": True
                    }
                }})
        e = ctx.exception
        self.assertEqual(e.message, "sku")

    def test_validate_fields_no_brand(self):
        with self.assertRaises(
                skylab_json_utils.SkylabMissingLabelException) as ctx:
            skylab_json_utils.validate_required_fields_for_skylab({
                "common": {
                    "labels": {
                        "board": True,
                        "model": True,
                        "sku": True
                    }
                }
            })
        e = ctx.exception
        self.assertEqual(e.message, "brand")

    def test_validate_fields_pass(self):
        item = {
            "common": {
                "labels": {
                    "board": True,
                    "model": True,
                    "sku": True,
                    "brand": True
                }
            }
        }
        # should complete without throwing exception
        skylab_json_utils.validate_required_fields_for_skylab(item)


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