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

"""Unittests for SDK stages."""

import json
import os

from chromite.cbuildbot import cbuildbot_unittest
from chromite.cbuildbot import commands
from chromite.cbuildbot.stages import generic_stages
from chromite.cbuildbot.stages import generic_stages_unittest
from chromite.cbuildbot.stages import sdk_stages
from chromite.lib import constants
from chromite.lib import cros_build_lib
from chromite.lib import cros_test_lib
from chromite.lib import osutils
from chromite.lib import perf_uploader
from chromite.lib import portage_util
from chromite.lib.buildstore import FakeBuildStore
from chromite.lib.parser import package_info
from chromite.scripts import upload_prebuilts


class SDKBuildToolchainsStageTest(
    generic_stages_unittest.AbstractStageTestCase,
    cbuildbot_unittest.SimpleBuilderTestCase,
):
    """Tests SDK toolchain building."""

    RELEASE_TAG = "ToT.0.0"

    def setUp(self):
        self.buildstore = FakeBuildStore()
        # This code has its own unit tests, so no need to go testing it here.
        self.run_mock = self.PatchObject(commands, "RunBuildScript")
        self.uploadartifact_mock = self.PatchObject(
            generic_stages.ArchivingStageMixin, "UploadArtifact"
        )

    def ConstructStage(self):
        self._run.GetArchive().SetupArchivePath()
        return sdk_stages.SDKBuildToolchainsStage(self._run, self.buildstore)

    def testNormal(self):
        """Basic run through the main code."""
        self._Prepare("chromiumos-sdk")
        self.PatchObject(
            os,
            "listdir",
            return_value=[
                "i686-pc.tar.xz",
                "x86_64-cros.tar.xz",
            ],
        )
        self.RunStage()
        self.assertEqual(self.run_mock.call_count, 2)
        self.assertEqual(self.uploadartifact_mock.call_count, 2)

        # Sanity check args passed to RunBuildScript.
        for call in self.run_mock.call_args_list:
            buildroot, cmd = call[0]
            self.assertIsInstance(buildroot, str)
            self.assertIsInstance(cmd, (tuple, list))
            for ele in cmd:
                self.assertIsInstance(ele, str)


class SDKPackageStageTest(
    generic_stages_unittest.AbstractStageTestCase,
    cbuildbot_unittest.SimpleBuilderTestCase,
):
    """Tests SDK package and Manifest creation."""

    RELEASE_TAG = "ToT.0.0"
    fake_packages = (
        ("cat1/package", "1"),
        ("cat1/package", "2"),
        ("cat2/package", "3"),
        ("cat2/package", "4"),
    )

    def setUp(self):
        self.buildstore = FakeBuildStore()
        # Replace sudo_run, since we don't care about sudo.
        self.PatchObject(cros_build_lib, "sudo_run", wraps=cros_build_lib.run)
        # Don't run CleanupMakeConfBoardSetup as it needs sudo_run.
        self.PatchObject(
            sdk_stages.SDKPackageStage, "CleanupMakeConfBoardSetup"
        )
        self.uploadartifact_mock = self.PatchObject(
            generic_stages.ArchivingStageMixin, "UploadArtifact"
        )
        # Prepare a fake chroot.
        self.fake_chroot = os.path.join(
            self.build_root, "chroot/build/amd64-host"
        )
        self.fake_json_data = {}
        osutils.SafeMakedirs(self.fake_chroot)
        osutils.Touch(os.path.join(self.fake_chroot, "file"))
        for package, v in self.fake_packages:
            cpv = package_info.SplitCPV("%s-%s" % (package, v))
            self.fake_json_data.setdefault(cpv.cp, []).append([v, {}])

    def ConstructStage(self):
        self._run.GetArchive().SetupArchivePath()
        return sdk_stages.SDKPackageStage(self._run, self.buildstore)

    def testTarballCreation(self):
        """Tests whether we package the tarball and correctly create a Manifest."""
        # We'll test this separately.
        self.PatchObject(sdk_stages.SDKPackageStage, "_SendPerfValues")

        self._Prepare("chromiumos-sdk")
        fake_tarball = os.path.join(self.build_root, "built-sdk.tar.xz")
        fake_manifest = os.path.join(
            self.build_root, "built-sdk.tar.xz.Manifest"
        )

        self.PatchObject(
            portage_util,
            "ListInstalledPackages",
            return_value=self.fake_packages,
        )

        self.RunStage()

        # Check tarball for the correct contents.
        output = cros_build_lib.run(
            ["tar", "-I", "xz", "-tvf", fake_tarball],
            encoding="utf-8",
            capture_output=True,
        ).stdout.splitlines()
        # First line is './', use it as an anchor, count the chars, and strip as
        # much from all other lines.
        stripchars = len(output[0]) - 1
        tar_lines = [x[stripchars:] for x in output]
        self.assertNotIn("/build/amd64-host/", tar_lines)
        self.assertIn("/file", tar_lines)
        # Verify manifest contents.
        real_json_data = json.loads(osutils.ReadFile(fake_manifest))
        self.assertEqual(real_json_data["packages"], self.fake_json_data)
        self.uploadartifact_mock.assert_called_once_with(
            fake_tarball, strict=True, archive=True
        )

    def testPerf(self):
        """Check perf data points are generated/uploaded."""
        m = self.PatchObject(perf_uploader, "UploadPerfValues")

        sdk_data = "asldjfasf"
        sdk_size = len(sdk_data)
        sdk_tarball = os.path.join(self.tempdir, "sdk.tar.xz")
        osutils.WriteFile(sdk_tarball, sdk_data)

        tarball_dir = os.path.join(
            self.tempdir,
            constants.DEFAULT_CHROOT_DIR,
            constants.SDK_TOOLCHAINS_OUTPUT,
        )
        arm_tar = os.path.join(tarball_dir, "arm-cros-linux-gnu.tar.xz")
        x86_tar = os.path.join(tarball_dir, "i686-pc-linux-gnu.tar.xz")
        osutils.Touch(arm_tar, makedirs=True)
        osutils.Touch(x86_tar, makedirs=True)

        self._Prepare("chromiumos-sdk")
        stage = self.ConstructStage()
        # pylint: disable=protected-access
        stage._SendPerfValues(
            self.tempdir, sdk_tarball, "http://some/log", "123.4.5.6", "sdk-bot"
        )
        # pylint: enable=protected-access

        perf_values = m.call_args[0][0]
        exp = perf_uploader.PerformanceValue(
            description="base",
            value=sdk_size,
            units="bytes",
            higher_is_better=False,
            graph="cros-sdk-size",
            stdio_uri="http://some/log",
        )
        self.assertEqual(exp, perf_values[0])

        exp = set(
            (
                perf_uploader.PerformanceValue(
                    description="arm-cros-linux-gnu",
                    value=0,
                    units="bytes",
                    higher_is_better=False,
                    graph="cros-sdk-size",
                    stdio_uri="http://some/log",
                ),
                perf_uploader.PerformanceValue(
                    description="i686-pc-linux-gnu",
                    value=0,
                    units="bytes",
                    higher_is_better=False,
                    graph="cros-sdk-size",
                    stdio_uri="http://some/log",
                ),
                perf_uploader.PerformanceValue(
                    description="base_plus_arm-cros-linux-gnu",
                    value=sdk_size,
                    units="bytes",
                    higher_is_better=False,
                    graph="cros-sdk-size",
                    stdio_uri="http://some/log",
                ),
                perf_uploader.PerformanceValue(
                    description="base_plus_i686-pc-linux-gnu",
                    value=sdk_size,
                    units="bytes",
                    higher_is_better=False,
                    graph="cros-sdk-size",
                    stdio_uri="http://some/log",
                ),
            )
        )
        self.assertEqual(exp, set(perf_values[1:]))

        platform_name = m.call_args[0][1]
        self.assertEqual(platform_name, "sdk-bot")

        test_name = m.call_args[0][2]
        self.assertEqual(test_name, "sdk")

        kwargs = m.call_args[1]
        self.assertEqual(kwargs["revision"], 123456)


class SDKTestStageTest(generic_stages_unittest.AbstractStageTestCase):
    """Tests SDK test phase."""

    def setUp(self):
        self.buildstore = FakeBuildStore()
        # This code has its own unit tests, so no need to go testing it here.
        self.run_mock = self.PatchObject(cros_build_lib, "run")

    def ConstructStage(self):
        return sdk_stages.SDKTestStage(self._run, self.buildstore)

    def testNormal(self):
        """Basic run through the main code."""
        self._Prepare("chromiumos-sdk")
        self.RunStage()


class SDKUprevStageTest(generic_stages_unittest.AbstractStageTestCase):
    """Tests SDK Uprev stage."""

    _VERSION = "2017.09.01.155318"

    def ConstructStage(self):
        return sdk_stages.SDKUprevStage(
            self._run, self.buildstore, version=self._VERSION
        )

    def testUprev(self):
        recorded_args = []
        self.PatchObject(
            upload_prebuilts,
            "RevGitFile",
            lambda *args, **kwargs: recorded_args.append(args),
        )

        out_dir = os.path.join(
            self.build_root, "chroot", "tmp", "toolchain-pkgs"
        )
        osutils.SafeMakedirs(out_dir)
        osutils.Touch(os.path.join(out_dir, "fake_sdk.tar.xz"))

        self._Prepare("chromiumos-sdk")

        self.RunStage()
        # upload_prebuilts.RevGitFile should be called exact once.
        self.assertEqual(1, len(recorded_args))
        sdk_conf, sdk_settings = recorded_args[0]
        self.assertEqual(
            sdk_conf,
            os.path.join(
                self.build_root,
                "src",
                "third_party",
                "chromiumos-overlay",
                "chromeos",
                "binhost",
                "host",
                "sdk_version.conf",
            ),
        )
        self.assertEqual(
            sdk_settings,
            {
                "SDK_LATEST_VERSION": self._VERSION,
                "TC_PATH": "2017/09/%(target)s-2017.09.01.155318.tar.xz",
            },
        )


class SDKUtilTest(cros_test_lib.RunCommandTempDirTestCase):
    """Tests various utility functions."""

    def testCreateTarballBasic(self):
        """Basic sanity checks for CreateTarball."""
        sdk_stages.CreateTarball(self.tempdir, "/chromite.tar")
        self.assertCommandContains(["tar", "/chromite.tar", "."])

    def testCreateTarballExclude(self):
        """Verify CreateTarball exclude_path handling."""
        sdk_stages.CreateTarball(
            self.tempdir,
            "/chromite.tar",
            exclude_paths=["tmp", "usr/lib/debug"],
        )
        self.assertCommandContains(
            [
                "tar",
                "--anchored",
                "--exclude=./tmp/*",
                "--exclude=./usr/lib/debug/*",
                "/chromite.tar",
                ".",
            ]
        )