# Copyright 2018 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 scripts/repo_sync_manifest."""

import os
from unittest import mock

from chromite.lib import cros_build_lib
from chromite.lib import cros_test_lib
from chromite.lib import git
from chromite.lib import osutils
from chromite.lib import parallel_unittest
from chromite.lib import repo_util
from chromite.scripts import create_manifest_snapshot
from chromite.utils import repo_manifest
from chromite.utils import repo_manifest_unittest


MANIFEST_XML = """<?xml version="1.0" encoding="UTF-8"?>
<manifest>
  <remote name="origin"/>
  <default remote="origin"/>
  <project name="project/a" revision="f01dab1e"/>
  <project name="project/b" revision="cafe1234" upstream="short"/>
  <project name="project/c" revision="deadbeef" upstream="refs/heads/main"/>
  <project name="dupe" revision="d1" upstream="dupe"/>
  <project name="dupe" revision="d2" upstream="dupe"/>
</manifest>
"""


class CreateManifestSnapshotTest(
    cros_test_lib.MockTempDirTestCase, repo_manifest_unittest.XMLTestCase
):
    """Unit tests for create_manifest_snapshot."""

    # pylint: disable=protected-access

    def setUp(self) -> None:
        self.manifest = repo_manifest.Manifest.FromString(MANIFEST_XML)
        self.project_a = self.manifest.GetUniqueProject("project/a")
        self.project_b = self.manifest.GetUniqueProject("project/b")
        self.project_c = self.manifest.GetUniqueProject("project/c")
        self.dupes = [x for x in self.manifest.Projects() if x.name == "dupe"]

        self.mock_is_reachable = self.PatchObject(git, "IsReachable")
        self.mock_git_push = self.PatchObject(git, "GitPush")

        self.repo_root = os.path.join(self.tempdir, "root")
        os.makedirs(os.path.join(self.repo_root, ".repo"))
        self.output_file = os.path.join(self.tempdir, "snapshot.xml")
        self.main_args = [
            "--repo-path",
            self.repo_root,
            "--log-level",
            "fatal",
            "--jobs",
            "1",
            "--output-file",
            self.output_file,
        ]
        self.PatchObject(
            repo_util.Repository, "Manifest", return_value=self.manifest
        )

    def testGetUpstreamBranchNoUpstream(self) -> None:
        """Test _GetUpstreamBranch with no upstream."""
        branch = create_manifest_snapshot._GetUpstreamBranch(self.project_a)
        self.assertIsNone(branch)

    def testGetUpstreamBranchShortUpstream(self) -> None:
        """Test _GetUpstreamBranch with short upstream ref."""
        branch = create_manifest_snapshot._GetUpstreamBranch(self.project_b)
        self.assertEqual(branch, "short")

    def testGetUpstreamBranchFullUpstream(self) -> None:
        """Test _GetUpstreamBranch with full upstream ref."""
        branch = create_manifest_snapshot._GetUpstreamBranch(self.project_c)
        self.assertEqual(branch, "main")

    def testNeedsSnapshotReachable(self) -> None:
        """Test _NeedsSnapshot with revision reachable from upstream."""
        self.mock_is_reachable.return_value = True
        result = create_manifest_snapshot._NeedsSnapshot("root", self.project_c)
        self.assertFalse(result)
        self.mock_is_reachable.assert_called_with(
            "root/project/c", "deadbeef", "refs/remotes/origin/main"
        )

    def testNeedsSnapshotUnreachable(self) -> None:
        """Test _NeedsSnapshot with revision reachable from upstream."""
        self.mock_is_reachable.return_value = False
        result = create_manifest_snapshot._NeedsSnapshot("root", self.project_b)
        self.assertTrue(result)
        self.mock_is_reachable.assert_called_with(
            "root/project/b", "cafe1234", "refs/remotes/origin/short"
        )

    def testNeedsSnapshotNoUpstream(self) -> None:
        """Test _NeedsSnapshot with no project upstream."""
        create_manifest_snapshot._NeedsSnapshot("root", self.project_a)
        self.mock_is_reachable.assert_called_with(
            "root/project/a", "f01dab1e", "refs/remotes/origin/main"
        )

    def testNeedsSnapshotIsReachableFailure(self) -> None:
        """Test _NeedsSnapshot with no project upstream."""
        self.mock_is_reachable.side_effect = cros_build_lib.RunCommandError("")
        result = create_manifest_snapshot._NeedsSnapshot("root", self.project_a)
        self.assertTrue(result)

    def testMakeUniqueRefMain(self) -> None:
        """Test _MakeUniqueRef with upstream main."""
        used = set()
        ref1 = create_manifest_snapshot._MakeUniqueRef(
            self.project_c, "base", used
        )
        ref2 = create_manifest_snapshot._MakeUniqueRef(
            self.project_c, "base", used
        )
        ref3 = create_manifest_snapshot._MakeUniqueRef(
            self.project_c, "base", used
        )
        self.assertEqual(ref1, "base")
        self.assertEqual(ref2, "base/1")
        self.assertEqual(ref3, "base/2")

    def testMakeUniqueRefNonMain(self) -> None:
        """Test _MakeUniqueRef with non-main upstream."""
        used = set()
        ref1 = create_manifest_snapshot._MakeUniqueRef(
            self.project_b, "base", used
        )
        ref2 = create_manifest_snapshot._MakeUniqueRef(
            self.project_b, "base", used
        )
        self.assertEqual(ref1, "base/short")
        self.assertEqual(ref2, "base/short/1")

    def testGitPushProjectUpstream(self) -> None:
        """Test _GitPushProjectUpstream."""
        create_manifest_snapshot._GitPushProjectUpstream(
            "root", self.project_b, False
        )
        self.mock_git_push.assert_called_with(
            "root/project/b",
            "cafe1234",
            git.RemoteRef("origin", "short"),
            dry_run=False,
        )

    def testGitPushProjectUpstreamDryRun(self) -> None:
        """Test _GitPushProjectUpstream with dry_run=True."""
        create_manifest_snapshot._GitPushProjectUpstream(
            "root", self.project_b, True
        )
        self.mock_git_push.assert_called_with(
            "root/project/b",
            "cafe1234",
            git.RemoteRef("origin", "short"),
            dry_run=True,
        )

    def testMainNoSnapshots(self) -> None:
        """Test main with projects that don't need snapshots."""
        self.mock_is_reachable.return_value = True
        create_manifest_snapshot.main(self.main_args)
        snapshot_xml = osutils.ReadFile(self.output_file)
        self.AssertXMLAlmostEqual(snapshot_xml, MANIFEST_XML)

    def testMainSnapshots(self) -> None:
        """Test main with projects that need snapshots."""
        self.mock_is_reachable.return_value = False
        args = self.main_args + ["--snapshot-ref", "refs/snap"]
        with parallel_unittest.ParallelMock():
            create_manifest_snapshot.main(args)
        snapshot_xml = osutils.ReadFile(self.output_file)

        self.mock_git_push.assert_has_calls(
            [
                mock.call(
                    os.path.join(self.repo_root, "project/a"),
                    "f01dab1e",
                    git.RemoteRef("origin", "refs/snap"),
                    dry_run=False,
                ),
                mock.call(
                    os.path.join(self.repo_root, "project/b"),
                    "cafe1234",
                    git.RemoteRef("origin", "refs/snap"),
                    dry_run=False,
                ),
                mock.call(
                    os.path.join(self.repo_root, "project/c"),
                    "deadbeef",
                    git.RemoteRef("origin", "refs/snap"),
                    dry_run=False,
                ),
                mock.call(
                    os.path.join(self.repo_root, "dupe"),
                    "d1",
                    git.RemoteRef("origin", "refs/snap/dupe"),
                    dry_run=False,
                ),
                mock.call(
                    os.path.join(self.repo_root, "dupe"),
                    "d2",
                    git.RemoteRef("origin", "refs/snap/dupe/1"),
                    dry_run=False,
                ),
            ],
            any_order=True,
        )

        expected = repo_manifest.Manifest.FromString(MANIFEST_XML)
        for project in expected.Projects():
            if project.name == "dupe":
                if project.revision == "d1":
                    project.upstream = "refs/snap/dupe"
                else:
                    project.upstream = "refs/snap/dupe/1"
            else:
                project.upstream = "refs/snap"
        expected_xml = repo_manifest_unittest.ManifestToString(expected)
        self.AssertXMLAlmostEqual(snapshot_xml, expected_xml)

    def testMainNeedsSnapshotNoSnapshotRef(self) -> None:
        """Test main with projects that need snapshots but no --snapshot-ref."""
        self.mock_is_reachable.return_value = False
        with self.assertRaises(SystemExit):
            create_manifest_snapshot.main(self.main_args)