xref: /aosp_15_r20/external/toolchain-utils/llvm_tools/get_patch_unittest.py (revision 760c253c1ed00ce9abd48f8546f08516e57485fe)

#!/usr/bin/env python3
# Copyright 2024 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 get_patch."""

import json
from pathlib import Path
import tempfile
from typing import Any, Dict, Generator, List, Set
import unittest
from unittest import mock

import get_patch
import git_llvm_rev


COMMIT_FIXTURES: List[Dict[str, Any]] = [
    {"subject": "A commit subject", "sha": "abcdef1234567890", "rev": 5},
    {"subject": "Another commit subject", "sha": "feed9999", "rev": 9},
]

JSON_FIXTURE: List[Dict[str, Any]] = [
    {
        "metadata": {"title": "An existing patch"},
        "platforms": ["another platform"],
        "rel_patch_path": "cherry/nowhere.patch",
        "version_range": {"from": 1, "until": 256},
    },
]


def _mock_get_commit_subj(_, sha: str) -> str:
    gen: Generator[Dict[str, Any], None, None] = (
        fixture for fixture in COMMIT_FIXTURES if fixture["sha"] == sha
    )
    return next(gen)["subject"]


def _mock_to_rev(sha: get_patch.LLVMGitRef, _) -> git_llvm_rev.Rev:
    gen: Generator[Dict[str, Any], None, None] = (
        fixture for fixture in COMMIT_FIXTURES if fixture["sha"] == sha.git_ref
    )
    return git_llvm_rev.Rev("main", next(gen)["rev"])


def _mock_from_rev(_, rev: git_llvm_rev.Rev) -> get_patch.LLVMGitRef:
    gen: Generator[Dict[str, Any], None, None] = (
        fixture for fixture in COMMIT_FIXTURES if fixture["rev"] == rev.number
    )
    return get_patch.LLVMGitRef(next(gen)["sha"])


def _mock_git_format_patch(*_) -> str:
    return "[category] This is a fake commit fixture"


def _mock_write_patch(*_) -> None:
    return


def _mock_get_changed_packages(*_) -> Set[Path]:
    return {get_patch.LLVM_PKG_PATH}


class TestGetPatch(unittest.TestCase):
    """Test case harness for get_patch."""

    def setUp(self) -> None:
        """Set up the mocks and directory structure."""

        self.module_patcher = mock.patch.multiple(
            "get_patch",
            get_commit_subj=_mock_get_commit_subj,
            git_format_patch=_mock_git_format_patch,
            get_changed_packages=_mock_get_changed_packages,
            _write_patch=_mock_write_patch,
        )
        self.module_patcher.start()
        self.addCleanup(self.module_patcher.stop)
        self.llvm_gitsha_patcher = mock.patch.multiple(
            "get_patch.LLVMGitRef",
            to_rev=_mock_to_rev,
            from_rev=_mock_from_rev,
        )
        self.llvm_gitsha_patcher.start()
        self.addCleanup(self.llvm_gitsha_patcher.stop)

        self.llvm_project_dir = Path(tempfile.mkdtemp())
        self.addCleanup(self.llvm_project_dir.rmdir)
        self.chromiumos_root = Path(tempfile.mkdtemp())
        self.addCleanup(self.chromiumos_root.rmdir)
        self.workdir = self.chromiumos_root / get_patch.LLVM_PKG_PATH / "files"
        self.workdir.mkdir(parents=True, exist_ok=True)

        def _cleanup_workdir():
            # We individually clean up these directories as a guarantee
            # we aren't creating any extraneous files. We don't want to
            # use shm.rmtree here because we don't want clean up any
            # files unaccounted for.
            workdir_recurse = self.workdir
            while workdir_recurse not in (self.chromiumos_root, Path.root):
                workdir_recurse.rmdir()
                workdir_recurse = workdir_recurse.parent

        self.addCleanup(_cleanup_workdir)

        self.patches_json_file = (
            self.workdir / get_patch.PATCH_METADATA_FILENAME
        )
        start_ref = get_patch.LLVMGitRef("abcdef1234567890")
        self.ctx = get_patch.PatchContext(
            self.llvm_project_dir,
            self.chromiumos_root,
            start_ref,
            platforms=["some platform"],
        )

    def write_json_fixture(self) -> None:
        with self.patches_json_file.open("w", encoding="utf-8") as f:
            json.dump(JSON_FIXTURE, f)
            f.write("\n")

    def test_bad_cherrypick_version(self) -> None:
        """Test that bad cherrypick versions raises."""
        start_sha_fixture = COMMIT_FIXTURES[0]

        def _try_make_patches():
            # This fixture is the same as the start_sha.
            self.ctx.make_patches(
                get_patch.LLVMGitRef(start_sha_fixture["sha"])
            )

        self.assertRaises(get_patch.CherrypickVersionError, _try_make_patches)

    def test_make_patches(self) -> None:
        """Test we can make patch entries from a git commit."""

        fixture = COMMIT_FIXTURES[1]
        # We manually write and delete this file because it must have the name
        # as specified by get_patch. tempfile cannot guarantee us this name.
        self.write_json_fixture()
        try:
            entries = self.ctx.make_patches(
                get_patch.LLVMGitRef(fixture["sha"])
            )
            self.assertEqual(len(entries), 1)
            if entries[0].metadata:
                self.assertEqual(
                    entries[0].metadata["title"], fixture["subject"]
                )
            else:
                self.fail("metadata was None")
        finally:
            self.patches_json_file.unlink()

    def test_apply_patch_to_json(self) -> None:
        """Test we can apply patches to the JSON file."""

        fixture = COMMIT_FIXTURES[1]
        fixture_sha = fixture["sha"]
        expected_json_entry = {
            "metadata": {"title": fixture["subject"], "info": []},
            "platforms": ["some platform"],
            "rel_patch_path": f"cherry/{fixture_sha}.patch",
            "version_range": {
                "from": self.ctx.start_ref.to_rev(self.llvm_project_dir).number,
                "until": fixture["rev"],
            },
        }
        cherrydir = self.workdir / "cherry"
        cherrydir.mkdir()
        self._apply_patch_to_json_helper(fixture, expected_json_entry)
        cherrydir.rmdir()

    def test_apply_patch_to_json_no_cherry(self) -> None:
        """Test we can apply patches to the JSON file, without a cherry dir."""

        fixture = COMMIT_FIXTURES[1]
        fixture_sha = fixture["sha"]
        expected_json_entry = {
            "metadata": {"title": fixture["subject"], "info": []},
            "platforms": ["some platform"],
            "rel_patch_path": f"{fixture_sha}.patch",
            "version_range": {
                "from": self.ctx.start_ref.to_rev(self.llvm_project_dir).number,
                "until": fixture["rev"],
            },
        }
        self._apply_patch_to_json_helper(fixture, expected_json_entry)

    def _apply_patch_to_json_helper(self, fixture, expected_json_entry) -> None:
        # We manually write and delete this file because it must have the name
        # as specified by get_patch. tempfile cannot guarantee us this name.
        self.write_json_fixture()
        patch_source = get_patch.LLVMGitRef.from_rev(
            self.llvm_project_dir,
            git_llvm_rev.Rev("origin", fixture["rev"]),
        )
        try:
            self.ctx.apply_patches(patch_source)
            with self.patches_json_file.open(encoding="utf-8") as f:
                edited = json.load(f)
            self.assertEqual(edited, JSON_FIXTURE + [expected_json_entry])
        finally:
            self.patches_json_file.unlink()

    def test_apply_patch_dry_run(self) -> None:
        """Test dry running patches does nothing."""

        fixture = COMMIT_FIXTURES[1]
        old_dry_run = self.ctx.dry_run
        self.ctx.dry_run = True
        # We manually write and delete this file because it must have the name
        # as specified by get_patch. tempfile cannot guarantee us this name.
        self.write_json_fixture()
        patch_source = get_patch.LLVMGitRef.from_rev(
            self.llvm_project_dir,
            git_llvm_rev.Rev("origin", fixture["rev"]),
        )
        try:
            self.ctx.apply_patches(patch_source)
            with self.patches_json_file.open(encoding="utf-8") as f:
                maybe_edited = json.load(f)
            self.assertEqual(maybe_edited, JSON_FIXTURE)
        finally:
            self.ctx.dry_run = old_dry_run
            self.patches_json_file.unlink()


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