tests/unittests/testllvmsourceconfig.py

import os
import unittest
import uuid

from sh import git
from unittest.mock import MagicMock, call

from linaropy.cd import cd
from linaropy.proj import Proj
from linaropy.git.clone import Clone
from linaropy.git.worktree import Worktree

from modules.llvm import LLVMSourceConfig, LLVMSubproject


class TestLLVMSourceConfig(unittest.TestCase):
    testdirprefix = "SourceConfigUT"

    def __create_dummy_commit(self):
        filename = "file" + str(uuid.uuid4())
        open(filename, "a").close()
        git("add", filename)
        git("commit", "-m", "Branches without commits confuse git")

    def __create_dummy_repo(self, path):
        if not os.path.exists(path):
            os.makedirs(path)

        with cd(path):
            git("init")
            self.__create_dummy_commit()

    def __get_subproj_repo_path(self, subproj):
        return os.path.join(self.originalLLVM.repodir, "..", subproj + "-repo")

    def __get_subproj_repo(self, subproj):
        return Clone(self.proj, self.__get_subproj_repo_path(subproj))

    def setUp(self):
        # We're going to create a hierarchy with [llvm|clang|whatever]-repo
        # containing dummy repos, and llvm-copy containing a worktree of
        # llvm-repo
        self.proj = Proj(prefix=TestLLVMSourceConfig.testdirprefix)
        path = os.path.join(self.proj.projdir, "llvm-repo")
        self.__create_dummy_repo(path)
        self.originalLLVM = Clone(self.proj, path)

        subprojs = LLVMSubproject.get_all_subprojects()
        for subproj in list(subprojs.keys()):
            repo = self.__get_subproj_repo_path(subproj)
            self.__create_dummy_repo(repo)

        self.temporaryLLVMbranch = "a-branch"
        self.temporaryLLVM = Worktree.create(
            self.proj, self.originalLLVM, os.path.join(
                self.proj.projdir, "llvm-copy"), self.temporaryLLVMbranch)

    def tearDown(self):
        self.proj.cleanup()

    def test_detect_enabled_all(self):
        subprojs = LLVMSubproject.get_all_subprojects()
        sourcePath = self.temporaryLLVM.repodir

        for subproj in subprojs:
            path = subprojs[subproj].get_cmake_path(sourcePath)
            worktree = Worktree.create(
                self.proj,
                self.__get_subproj_repo(subproj),
                path,
                self.temporaryLLVMbranch)
            self.assertTrue(os.path.isdir(path), "Failed to create worktree")

        config = LLVMSourceConfig(self.proj, sourcePath)
        enabled = config.get_enabled_subprojects()

        self.assertEqual(set(subprojs), set(enabled),
                         "Expected %s but detected only %s" %
                         (str(set(subprojs)), str(enabled)))

    def test_detect_enabled_none(self):
        sourcePath = self.temporaryLLVM.repodir

        path = os.path.join(sourcePath, "unrelated")
        os.makedirs(path)

        path = os.path.join(sourcePath, "wrong", "place", "for", "lld")
        os.makedirs(path)

        path = os.path.join(sourcePath, "projects", "clang")
        os.makedirs(path)

        path = os.path.join(sourcePath, "tools", "libcxx")
        os.makedirs(path)

        config = LLVMSourceConfig(self.proj, sourcePath)
        enabled = config.get_enabled_subprojects()

        self.assertEqual(
            enabled,
            [],
            "Detected unexpected projects %s" % str(enabled)
        )

    def test_detect_enabled_some(self):
        sourcePath = self.temporaryLLVM.repodir
        subprojs = LLVMSubproject.get_all_subprojects()

        for subproj in ["lld", "libcxxabi", "clang"]:
            path = subprojs[subproj].get_cmake_path(sourcePath)
            worktree = Worktree.create(
                self.proj,
                self.__get_subproj_repo(subproj),
                path,
                self.temporaryLLVMbranch)
            self.assertTrue(os.path.isdir(path), "Failed to create worktree")

        config = LLVMSourceConfig(self.proj, sourcePath)
        enabled = config.get_enabled_subprojects()

        self.assertTrue("lld" in enabled, "Failed to detect lld")
        self.assertTrue("clang" in enabled, "Failed to detect clang")
        self.assertTrue("libcxxabi" in enabled,
                        "Failed to detect libcxxabi")

    def test_detect_enabled_not_worktree(self):
        sourcePath = self.temporaryLLVM.repodir
        subprojs = LLVMSubproject.get_all_subprojects()

        path = subprojs["compiler-rt"].get_cmake_path(sourcePath)
        os.makedirs(path)

        config = LLVMSourceConfig(self.proj, sourcePath)
        with self.assertRaises(EnvironmentError) as context:
            config.get_enabled_subprojects()

        self.assertRegex(
            str(context.exception),
            ".*compiler-rt is not a worktree.*"
        )

    def test_detect_enabled_wrong_branch(self):
        sourcePath = self.temporaryLLVM.repodir
        subprojs = LLVMSubproject.get_all_subprojects()

        path = subprojs["compiler-rt"].get_cmake_path(sourcePath)
        branch = "different-than-" + self.temporaryLLVMbranch
        worktree = Worktree.create(
            self.proj,
            self.__get_subproj_repo("compiler-rt"),
            path,
            branch)
        self.assertTrue(os.path.isdir(path), "Failed to create worktree")

        config = LLVMSourceConfig(self.proj, sourcePath)
        with self.assertRaises(EnvironmentError) as context:
            config.get_enabled_subprojects()

        self.assertRegex(str(context.exception),
                         "compiler-rt is on branch {}, but should be on {}".format(branch,
                                                                                   self.temporaryLLVMbranch))

    def test_add_invalid_subproject(self):
        config = LLVMSourceConfig(self.proj, self.temporaryLLVM.repodir)
        subproj = "not-an-llvm-subproject"
        subprojPath = self.originalLLVM.repodir  # Dummy path

        with self.assertRaises(ValueError) as context:
            config.update({subproj : Clone(self.proj, subprojPath)})

        self.assertRegex(str(context.exception),
                         "Unknown llvm subproject %s" % subproj)

    def test_add_each_subproject(self):
        sourcePath = self.temporaryLLVM.repodir

        config = LLVMSourceConfig(self.proj, sourcePath)

        subprojs = LLVMSubproject.get_all_subprojects()
        for subproj in subprojs:
            expectedPath = subprojs[subproj].get_cmake_path(sourcePath)
            config.update({subproj : self.__get_subproj_repo(subproj)})
            self.assertTrue(os.path.isdir(expectedPath),
                            "Failed to add subproject %s" % subproj)

    def test_add_all_subprojects(self):
        sourcePath = self.temporaryLLVM.repodir

        config = LLVMSourceConfig(self.proj, sourcePath)

        to_add = {}
        subprojs = LLVMSubproject.get_all_subprojects()

        for subproj in subprojs:
            to_add[subproj] = self.__get_subproj_repo(subproj)

        config.update(to_add)

        for subproj in subprojs:
            expectedPath = subprojs[subproj].get_cmake_path(sourcePath)
            self.assertTrue(os.path.isdir(expectedPath),
                            "Failed to add subproject %s" % subproj)

    def test_add_some_subprojects(self):
        sourcePath = self.temporaryLLVM.repodir

        config = LLVMSourceConfig(self.proj, sourcePath)

        to_add = {}
        to_add["clang"] = self.__get_subproj_repo("clang")
        to_add["compiler-rt"] = self.__get_subproj_repo("compiler-rt")

        config.update(to_add)

        subprojs = LLVMSubproject.get_all_subprojects()
        self.assertTrue(
            os.path.isdir(subprojs["clang"].get_cmake_path(sourcePath)),
            "Failed to add subproject clang")
        self.assertTrue(
            os.path.isdir(subprojs["compiler-rt"].get_cmake_path(sourcePath)),
            "Failed to add subproject compiler-rt")

    def test_add_existing_subprojects(self):
        sourcePath = self.temporaryLLVM.repodir

        config = LLVMSourceConfig(self.proj, sourcePath)

        subprojs = LLVMSubproject.get_all_subprojects()
        existingPath = subprojs["lldb"].get_cmake_path(sourcePath)
        Worktree.create(
            self.proj,
            self.__get_subproj_repo("lldb"),
            existingPath,
            self.temporaryLLVMbranch)

        config.update({ "lldb" : self.__get_subproj_repo("lldb")})

        # If we got this far, we're probably ok, but let's be pedantic and check
        # that the subproject is still there
        self.assertTrue(os.path.isdir(existingPath),
                        "Existing subproject vanished")

    def test_add_subproject_existing_branch(self):
        """
        Test that we can add a subproject that already has the branch that LLVM
        is on. This can happen for instance if we have added and then removed
        the subproject and now we're trying to add it again.
        """
        sourcePath = self.temporaryLLVM.repodir

        config = LLVMSourceConfig(self.proj, sourcePath)

        clangRepo = self.__get_subproj_repo("clang")
        with cd(clangRepo.repodir):
            # Make sure that the branch that LLVM is on already exists in the
            # clang repo as well.
            git("checkout", "-b", self.temporaryLLVMbranch)
            self.__create_dummy_commit()
            git("checkout", "master")

        config.update( { "clang" : clangRepo })

        subprojs = LLVMSubproject.get_all_subprojects()
        path = subprojs["clang"].get_cmake_path(sourcePath)
        self.assertTrue(os.path.isdir(path), "Failed to add subproject")

    def test_add_subproject_not_a_worktree(self):
        """
        Test that we can't update a config to include a subproject that exists
        but is not a worktree.
        """
        sourcePath = self.temporaryLLVM.repodir
        branch = "different-than-" + self.temporaryLLVMbranch

        config = LLVMSourceConfig(self.proj, sourcePath)

        subprojs = LLVMSubproject.get_all_subprojects()
        existingPath = subprojs["lldb"].get_cmake_path(sourcePath)
        os.makedirs(existingPath)

        with self.assertRaises(EnvironmentError) as context:
            config.update({ "lldb" : self.__get_subproj_repo("lldb")})

        self.assertRegex(str(context.exception),
                         "{} is not a worktree.*"
                         .format(existingPath))

        # If we got this far, we're probably ok, but let's be pedantic and check
        # that the subproject is still there
        self.assertTrue(os.path.isdir(existingPath),
                        "Existing subproject vanished")

    def test_add_subproject_wrong_branch(self):
        """
        Test that we can't update a config to include a subproject that exists
        but is on the wrong branch.
        """
        sourcePath = self.temporaryLLVM.repodir
        branch = "different-than-" + self.temporaryLLVMbranch

        config = LLVMSourceConfig(self.proj, sourcePath)

        subprojs = LLVMSubproject.get_all_subprojects()
        existingPath = subprojs["lldb"].get_cmake_path(sourcePath)
        Worktree.create(
            self.proj,
            self.__get_subproj_repo("lldb"),
            existingPath,
            branch)

        with self.assertRaises(EnvironmentError) as context:
            config.update({ "lldb" : self.__get_subproj_repo("lldb")})

        self.assertRegex(str(context.exception),
                         "lldb is on branch {}, but should be on {}.*"
                         .format(branch, self.temporaryLLVMbranch))

        # If we got this far, we're probably ok, but let's be pedantic and check
        # that the subproject is still there
        self.assertTrue(os.path.isdir(existingPath),
                        "Existing subproject vanished")

    def test_remove_subproject(self):
        sourcePath = self.temporaryLLVM.repodir

        subprojs = LLVMSubproject.get_all_subprojects()

        lldPath = subprojs["lld"].get_cmake_path(sourcePath)
        lldWorktree = Worktree.create(
            self.proj,
            self.__get_subproj_repo("lld"),
            lldPath,
            self.temporaryLLVMbranch)

        clangPath = subprojs["clang"].get_cmake_path(sourcePath)
        clangWorktree = Worktree.create(
            self.proj,
            self.__get_subproj_repo("clang"),
            clangPath,
            self.temporaryLLVMbranch)

        config = LLVMSourceConfig(self.proj, sourcePath)
        config.update(remove=["lld"])

        self.assertFalse(os.path.isdir(lldPath), "Failed to remove subproject")
        self.assertTrue(os.path.isdir(clangPath), "Removed sibling subproject")

    def test_remove_some_subprojects(self):
        sourcePath = self.temporaryLLVM.repodir

        subprojs = LLVMSubproject.get_all_subprojects()

        for subproj in ["clang", "compiler-rt", "lld", "lldb", "libunwind"]:
            path = subprojs[subproj].get_cmake_path(sourcePath)
            worktree = Worktree.create(
                self.proj,
                self.__get_subproj_repo(subproj),
                path,
                self.temporaryLLVMbranch)

        config = LLVMSourceConfig(self.proj, sourcePath)
        config.update(remove=["compiler-rt", "lld"])

        for subproj in ["compiler-rt", "lld"]:
            path = subprojs[subproj].get_cmake_path(sourcePath)
            self.assertFalse(
                os.path.isdir(path),
                "Failed to remove subproject")

        for subproj in ["clang", "lldb", "libunwind"]:
            path = subprojs[subproj].get_cmake_path(sourcePath)
            self.assertTrue(os.path.isdir(path), "Removed sibling subproject")

    def test_remove_all_subprojects(self):
        sourcePath = self.temporaryLLVM.repodir

        subprojs = LLVMSubproject.get_all_subprojects()

        for subproj in list(subprojs.keys()):
            path = subprojs[subproj].get_cmake_path(sourcePath)
            worktree = Worktree.create(
                self.proj,
                self.__get_subproj_repo(subproj),
                path,
                self.temporaryLLVMbranch)
            self.assertTrue(os.path.isdir(path), "Failed to create worktree")

        config = LLVMSourceConfig(self.proj, sourcePath)
        config.update(remove=list(subprojs.keys()))

        for subproj in list(subprojs.keys()):
            path = subprojs[subproj].get_cmake_path(sourcePath)
            self.assertFalse(
                os.path.isdir(path),
                "Failed to remove subproject")

    def test_remove_each_subproject(self):
        sourcePath = self.temporaryLLVM.repodir

        subprojs = LLVMSubproject.get_all_subprojects()

        for subproj in list(subprojs.keys()):
            path = subprojs[subproj].get_cmake_path(sourcePath)
            worktree = Worktree.create(
                self.proj,
                self.__get_subproj_repo(subproj),
                path,
                self.temporaryLLVMbranch)
            self.assertTrue(os.path.isdir(path), "Failed to create worktree")

        config = LLVMSourceConfig(self.proj, sourcePath)

        for subproj in list(subprojs.keys()):
            config.update(remove=[subproj])

        for subproj in list(subprojs.keys()):
            path = subprojs[subproj].get_cmake_path(sourcePath)
            self.assertFalse(
                os.path.isdir(path),
                "Failed to remove subproject")

    def test_remove_duplicates(self):
        sourcePath = self.temporaryLLVM.repodir

        subprojs = LLVMSubproject.get_all_subprojects()

        for subproj in ["clang", "compiler-rt", "lld", "lldb", "libunwind"]:
            path = subprojs[subproj].get_cmake_path(sourcePath)
            worktree = Worktree.create(
                self.proj,
                self.__get_subproj_repo(subproj),
                path,
                self.temporaryLLVMbranch)

        config = LLVMSourceConfig(self.proj, sourcePath)
        config.update(remove=["compiler-rt", "lld", "lld", "compiler-rt"])

        for subproj in ["compiler-rt", "lld"]:
            path = subprojs[subproj].get_cmake_path(sourcePath)
            self.assertFalse(
                os.path.isdir(path),
                "Failed to remove subproject")

        for subproj in ["clang", "lldb", "libunwind"]:
            path = subprojs[subproj].get_cmake_path(sourcePath)
            self.assertTrue(os.path.isdir(path), "Removed sibling subproject")

    def test_remove_invalid_subproject(self):
        sourcePath = self.temporaryLLVM.repodir
        config = LLVMSourceConfig(self.proj, sourcePath)

        subproj = "not-an-llvm-subproject"

        with self.assertRaises(ValueError) as context:
            config.update(remove=[subproj])

        self.assertRegex(str(context.exception),
                         "Unknown llvm subproject %s" % subproj)

    def test_remove_inexistent_subproject(self):
        sourcePath = self.temporaryLLVM.repodir

        subprojs = LLVMSubproject.get_all_subprojects()

        lldPath = subprojs["lld"].get_cmake_path(sourcePath)
        lldWorktree = Worktree.create(
            self.proj,
            self.__get_subproj_repo("lld"),
            lldPath,
            self.temporaryLLVMbranch)

        clangPath = subprojs["clang"].get_cmake_path(sourcePath)

        config = LLVMSourceConfig(self.proj, sourcePath)
        config.update(remove=["clang"])

        self.assertFalse(
            os.path.isdir(clangPath),
            "Failed to remove subproject")
        self.assertTrue(os.path.isdir(lldPath), "Removed sibling subproject")

    def test_add_after_remove(self):
        sourcePath = self.temporaryLLVM.repodir

        subprojs = LLVMSubproject.get_all_subprojects()
        lldbRepo = self.__get_subproj_repo("lldb")

        config = LLVMSourceConfig(self.proj, sourcePath)

        config.update({"lldb" : lldbRepo})
        self.assertTrue(
            os.path.isdir(subprojs["lldb"].get_cmake_path(sourcePath)),
            "Failed to add lldb")

        config.update(remove=["lldb"])
        self.assertFalse(
            os.path.isdir(subprojs["lldb"].get_cmake_path(sourcePath)),
            "Failed to remove lldb")

        config.update({"lldb" : lldbRepo })
        self.assertTrue(
            os.path.isdir(subprojs["lldb"].get_cmake_path(sourcePath)),
            "Failed to add lldb")

    def test_mixed_adds_removes(self):
        sourcePath = self.temporaryLLVM.repodir

        subprojs = LLVMSubproject.get_all_subprojects()

        for subproj in ["clang", "compiler-rt", "lld", "lldb", "libunwind"]:
            path = subprojs[subproj].get_cmake_path(sourcePath)
            worktree = Worktree.create(
                self.proj,
                self.__get_subproj_repo(subproj),
                path,
                self.temporaryLLVMbranch)

        config = LLVMSourceConfig(self.proj, sourcePath)
        config.update({
                "libcxx" : self.__get_subproj_repo("libcxx"),
                "libcxxabi" : self.__get_subproj_repo("libcxxabi")},
                ["compiler-rt", "lld"])

        for subproj in ["libcxx", "libcxxabi"]:
            path = subprojs[subproj].get_cmake_path(sourcePath)
            self.assertTrue(os.path.isdir(path), "Failed to add subproject")

        for subproj in ["compiler-rt", "lld"]:
            path = subprojs[subproj].get_cmake_path(sourcePath)
            self.assertFalse(
                os.path.isdir(path),
                "Failed to remove subproject")

        for subproj in ["clang", "lldb", "libunwind"]:
            path = subprojs[subproj].get_cmake_path(sourcePath)
            self.assertTrue(os.path.isdir(path), "Removed sibling subproject")

    def test_simultaneous_add_remove(self):
        sourcePath = self.temporaryLLVM.repodir
        subprojs = LLVMSubproject.get_all_subprojects()

        clangRepo = self.__get_subproj_repo("clang")
        lldRepo = self.__get_subproj_repo("lld")
        libunwindRepo = self.__get_subproj_repo("libunwind")

        config = LLVMSourceConfig(self.proj, sourcePath)
        with self.assertRaises(ValueError) as context:
            config.update(
                    { "clang" : clangRepo, "lld" : lldRepo, "libunwind" :
                        libunwindRepo}, ["libcxx", "lld", "libcxxabi"])

        self.assertEqual(str(context.exception),
                         "Can't add and remove lld at the same time")

        # Make sure we didn't add any of the others either
        for subproj in ["clang", "libunwind"]:
            path = subprojs[subproj].get_cmake_path(sourcePath)
            self.assertFalse(
                os.path.isdir(path),
                "Incorrectly added subproject")

    # TODO: test with a different dictionary than the default one (not
    # necessarily containing subprojects - it can contain "potato", "banana" and
    # "gazpacho" for all we care); in fact, it would probably be best to move the
    # existing tests to that...

    # TODO: test that CMake gets our layout

    def test_for_each_enabled(self):
        sourcePath = self.temporaryLLVM.repodir

        config = LLVMSourceConfig(self.proj, sourcePath)

        logPath = unittest.mock.MagicMock()
        config.for_each_enabled(logPath)

        logPath.assert_called_with(self.temporaryLLVM.repodir)

        subprojs = config.subprojs
        enabled = ["clang", "compiler-rt", "lld", "lldb", "libunwind"]
        calls = []

        for subproj in enabled:
            path = subprojs[subproj].get_cmake_path(sourcePath)
            worktree = Worktree.create(
                self.proj,
                self.__get_subproj_repo(subproj),
                path,
                self.temporaryLLVMbranch)
            calls.append(call(path))  # Expect our mock to be called with path

        logPath = unittest.mock.MagicMock()
        config.for_each_enabled(logPath)

        logPath.assert_has_calls(calls, any_order=True)

    def test_for_each_enabled_error(self):
        """Test that we rethrow exceptions correctly."""
        sourcePath = self.temporaryLLVM.repodir

        config = LLVMSourceConfig(self.proj, sourcePath)
        subprojs = config.subprojs
        enabled = ["clang", "compiler-rt", "lld", "lldb", "libunwind"]

        for subproj in enabled:
            path = subprojs[subproj].get_cmake_path(sourcePath)
            worktree = Worktree.create(
                self.proj,
                self.__get_subproj_repo(subproj),
                path,
                self.temporaryLLVMbranch)

        def throw(projPath):
            if "lld" in projPath:
                raise ValueError("An error has been!!1")

        with self.assertRaises(RuntimeError) as context:
            config.for_each_enabled(throw)
        self.assertRegex(str(context.exception),
                         "Error while processing lld(.*\n)*")
        self.assertRegex(str(context.exception.__cause__),
                         "An error has been!!1(.*\n)*")

    def test_for_each_subproj(self):
        sourcePath = self.temporaryLLVM.repodir

        config = LLVMSourceConfig(self.proj, sourcePath)

        subprojs = config.subprojs
        enabled = ["clang", "compiler-rt", "lld", "lldb", "libunwind"]
        calls = []

        for subproj in enabled:
            # Make sure subproj looks enabled
            path = subprojs[subproj].get_cmake_path(sourcePath)
            worktree = Worktree.create(
                self.proj,
                self.__get_subproj_repo(subproj),
                path,
                self.temporaryLLVMbranch)
            # Expect our mock to be called with the proper subproj and
            # enabled == True
            calls.append(call(subprojs[subproj], True))

        for subproj in set(subprojs.keys()) - set(enabled):
            # Expect our mock to be called with the proper subproj and
            # enabled == False
            calls.append(call(subprojs[subproj], False))

        try:
            action = MagicMock()
            config.for_each_subproj(action)
        except:
            print("Exception during test?! ")

        action.assert_has_calls(calls, any_order=True)

    def test_for_each_subproj_error(self):
        """Test that we rethrow exceptions correctly."""
        sourcePath = self.temporaryLLVM.repodir

        config = LLVMSourceConfig(self.proj, sourcePath)
        subprojs = config.subprojs
        enabled = ["clang", "compiler-rt", "lld", "lldb", "libunwind"]

        for subproj in enabled:
            path = subprojs[subproj].get_cmake_path(sourcePath)
            worktree = Worktree.create(
                self.proj,
                self.__get_subproj_repo(subproj),
                path,
                self.temporaryLLVMbranch)

        def throw_enabled(subproj, enabled):
            # Throw for one of the enabled projects (e.g. lld)
            if "lld" in subproj.cmake_path:
                raise ValueError("An error has been!!1")

        def throw_disabled(subproj, enabled):
            # Throw for one of the disabled projects (e.g. libcxx)
            if "libcxx" in subproj.cmake_path:
                raise ValueError("An error has been!!1")

        with self.assertRaises(RuntimeError) as context:
            config.for_each_subproj(throw_enabled)
        self.assertRegex(str(context.exception),
                         "Error while processing lld(.*\n)*")
        self.assertRegex(str(context.exception.__cause__),
                         "An error has been!!1(.*\n)*")

        with self.assertRaises(RuntimeError) as context:
            config.for_each_subproj(throw_disabled)
        self.assertRegex(str(context.exception),
                         "Error while processing libcxx(.*\n)*")
        self.assertRegex(str(context.exception.__cause__),
                         "An error has been!!1(.*\n)*")


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