tests/cli/testllvmprojects.py

"""Command line interface tests for llvmprojs.py

Note that although this uses the unittest framework, it does *not* contain unit
tests.

"""

import shutil
import os
import subprocess
import unittest

from functools import partial
from tempfile import mkdtemp
from uuid import uuid4

from linaropy.cd import cd


# TODO: move this somewhere more public (maybe linaropy?)
def debug(test):
    """
    Decorator that dumps the output of any subprocess.CalledProcessError
    exception. Use this to decorate a test function when you can't tell what the
    problem is.
    """
    def wrapper(*args, **kwargs):
        # Catch any exceptions so we can dump all the output
        try:
            test(*args, **kwargs)
        except subprocess.CalledProcessError as exc:
            print "Error in {}:".format(test.__name__)
            print "Command {} exited with error code {}:\n{}".format(
                exc.cmd, exc.returncode, exc.output)
    return wrapper


class Testllvmprojs(unittest.TestCase):
    script = os.path.join("scripts", "llvm.py")

    @classmethod
    def __create_dummy_commit(cls):
        filename = "filethatshouldntexist"
        cls.run_quietly(["touch", filename])
        cls.run_quietly(["git", "add", filename])
        cls.run_quietly(["git", "commit", "-m", "Dummy commit"])

    @classmethod
    def __create_dummy_repo(cls, repopath):
        if not os.path.isdir(repopath):
            os.makedirs(repopath)

        with cd(repopath):
            cls.run_quietly(["git", "init"])
            cls.__create_dummy_commit()

    @classmethod
    def __add_worktree(cls, repopath, worktreepath, branch):
        with cd(repopath):
            cls.run_quietly(["git", "worktree", "add", worktreepath,
                             "-b", branch])

    @classmethod
    def __get_subproj_repo(cls, subproj):
        return os.path.join(cls.repos, subproj)

    @classmethod
    def setUpClass(cls):
        """Create the file structure and environment that llvmprojs expects"""
        cls.llvm_root = mkdtemp()
        cls.repos = os.path.join(cls.llvm_root, "repos")

        cls.all_repos = ("llvm", "clang", "compiler-rt", "lld", "lldb",
                         "libcxx", "libcxxabi", "libunwind", "test-suite")

        # Set up helper functions for running commands (this needs to be done
        # before creating the repos)
        # FIXME: In newer versions of Python (3.3+) we should be able to bind
        # the stdout to DEVNULL, as below:
        # cls.run_quietly = partial(subprocess.call, stdout=subprocess.DEVNULL)
        # This doesn't work in Python 2, so we'll just have to ignore the output
        # for now...
        cls.run_with_output = partial(subprocess.check_output,
                                      stderr=subprocess.STDOUT)
        cls.run_quietly = cls.run_with_output

        # Create dummy repos
        for reponame in cls.all_repos:
            cls.__create_dummy_repo(cls.__get_subproj_repo(reponame))

    @classmethod
    def tearDownClass(cls):
        shutil.rmtree(cls.llvm_root)

    @classmethod
    def setUp(cls):
        cls.llvm_src = os.path.join(cls.llvm_root, "src" + str(uuid4()))

        # Create LLVM worktree
        cls.branch = "br" + str(uuid4())
        cls.__add_worktree(cls.__get_subproj_repo("llvm"), cls.llvm_src,
                           cls.branch)

        # Set up the environment variables
        os.environ["LLVM_ROOT"] = cls.llvm_root
        os.environ["LLVM_SRC"] = cls.llvm_src

    @classmethod
    def tearDown(cls):
        # Clean up the directories where we might have added subprojects.
        # This isn't 100% clean, because we don't clean up the repos between
        # tests (so any branches will remain), but it's good enough for the
        # current tests.
        for subprojdir in (os.path.join(cls.llvm_src, "projects"),
                           os.path.join(cls.llvm_src, "tools")):
            if os.path.isdir(subprojdir):
                shutil.rmtree(subprojdir)
                os.makedirs(subprojdir)

        # Run prune on the original repos, to remove any dangling worktrees.
        for reponame in cls.all_repos:
            repopath = cls.__get_subproj_repo(reponame)
            with cd(repopath):
                cls.run_quietly(["git", "worktree", "prune"])

    def test_dump_empty_config(self):
        """
        Test that we're correctly dumping an empty configuration (i.e. no
        projects linked) when running llvmprojs without arguments.
        """
        output = self.run_with_output(["python", self.script, "projects"])
        self.assertRegexpMatches(output, "Projects linked:.*\n.*none.*")

    def test_add_remove_subprojects(self):
        """
        Test that we can add and remove one or several subprojects.
        """
        output = self.run_with_output(["python", self.script, "projects",
                                       "--add", "clang"])
        self.assertRegexpMatches(output, "Projects linked:.*\n.*clang.*")

        output = self.run_with_output(["python", self.script, "projects",
                                       "--add", "libcxx", "lldb"])
        self.assertRegexpMatches(
            output,
            "Projects linked:.*\n" +
            ".*clang.*\n" +
            ".*libcxx.*\n" +
            ".*lldb.*")

        output = self.run_with_output(["python", self.script, "projects",
                                       "--remove", "libcxx"])
        self.assertRegexpMatches(output,
                                 "Projects linked:.*\n" +
                                 ".*clang.*\n" +
                                 ".*lldb.*")

        output = self.run_with_output(["python", self.script, "projects",
                                       "--remove", "clang", "lldb"])
        self.assertRegexpMatches(output,
                                 "Projects linked:.*\n" +
                                 ".*none.*")

    def test_add_remove_invalid_subprojects(self):
        """
        Test that we error out nicely when trying to add/remove invalid
        subprojects.
        """
        with self.assertRaises(subprocess.CalledProcessError) as context:
            self.run_quietly(["python", self.script, "projects",
                              "--add", "inventedsubproject"])

        self.assertRegexpMatches(
            context.exception.output,
            "(.*\n)*.*invalid choice:.*inventedsubproject(.*\n)*")

        with self.assertRaises(subprocess.CalledProcessError) as context:
            self.run_quietly(["python", self.script, "projects",
                              "--remove", "inventedsubproject"])

        self.assertRegexpMatches(
            context.exception.output,
            "(.*\n)*.*invalid choice:.*inventedsubproject(.*\n)*")

    def test_duplicate_add_remove(self):
        """
        Test that we don't crash when trying to add / remove the same subproject
        twice with the same command.
        """
        output = self.run_with_output(["python", self.script, "projects",
                                       "--add", "clang", "lld", "clang"])
        self.assertRegexpMatches(output,
                                 "Projects linked:.*\n" +
                                 ".*clang.*\n" +
                                 ".*lld.*")

        output = self.run_with_output(["python", self.script, "projects",
                                       "--remove", "lld", "lld", "clang"])
        self.assertRegexpMatches(output,
                                 "Projects linked:.*\n" +
                                 ".*none.*")

    def test_redundant_add_remove(self):
        """
        Test that we can add a subproject that already exists (either because it
        was added by our script or manually) or remove a subproject that doesn't
        exist.
        """
        self.__add_worktree(self.__get_subproj_repo("clang"),
                            os.path.join(self.llvm_src, "tools", "clang"),
                            self.branch)
        self.__add_worktree(
            self.__get_subproj_repo("compiler-rt"),
            os.path.join(self.llvm_src, "projects", "compiler-rt"),
            self.branch)

        output = self.run_with_output(["python", self.script, "projects",
                                       "--add", "clang"])
        self.assertRegexpMatches(output,
                                 "Projects linked:.*\n" +
                                 ".*clang.*")

        output = self.run_with_output(["python", self.script, "projects",
                                       "--add", "compiler-rt", "lld"])
        self.assertRegexpMatches(
            output,
            "Projects linked:.*\n" +
            ".*clang.*\n" +
            ".*compiler-rt.*\n" +
            ".*lld.*")

        output = self.run_with_output(["python", self.script, "projects",
                                       "--remove", "lldb", "libcxx", "lld"])
        self.assertRegexpMatches(
            output,
            "Projects linked:.*\n" +
            ".*clang.*\n" +
            ".*compiler-rt.*")

    def test_simultaneous_add_remove(self):
        """
        Test that we error out when someone is trying to add and remove the same
        project with the same command.
        """
        # Try the really basic case and make sure we're not touching anything
        with self.assertRaises(subprocess.CalledProcessError) as context:
            self.run_quietly(["python", self.script, "projects",
                              "--add", "clang", "--remove", "clang"])

        self.assertRegexpMatches(
            context.exception.output,
            "(.*\n)*.*Can't add and remove clang at the same time(.*\n)*")

        self.assertFalse(
            os.path.exists(
                os.path.join(self.llvm_src, "tools", "clang")))

        # Try something a bit more complicated and make sure we're not touching
        # anything
        self.__add_worktree(
            self.__get_subproj_repo("lld"),
            os.path.join(self.llvm_src, "tools", "lld"),
            self.branch)

        with self.assertRaises(subprocess.CalledProcessError) as context:
            self.run_quietly(["python", self.script, "projects",
                              "--add", "clang", "lld", "libcxx",
                              "--remove", "lld", "libcxx"])
        self.assertRegexpMatches(
            context.exception.output,
            "(.*\n)*" +
            ".*Can't add and remove (lld|libcxx) at the same time(.*\n)*")

        # Make sure we didn't touch anything
        self.assertFalse(
            os.path.exists(
                os.path.join(self.llvm_src, "tools", "clang")))
        self.assertTrue(
            os.path.exists(
                os.path.join(self.llvm_src, "tools", "lld")))
        self.assertFalse(
            os.path.exists(
                os.path.join(self.llvm_src, "projects", "libcxx")))

    def test_multiple_adds_removes(self):
        """
        Test that we can have multiple --add and --remove options in the same
        command and that only the last one of each kind matters.
        """
        output = self.run_with_output(["python", self.script, "projects",
                                       "--add", "libcxxabi",
                                       "--remove", "lld", "lldb",
                                       "--add", "clang", "libcxx",
                                       "--remove", "libunwind"])
        self.assertRegexpMatches(output,
                                 "Projects linked:.*\n" +
                                 ".*clang.*\n" +
                                 ".*libcxx.*\n")

        output = self.run_with_output(["python", self.script, "projects",
                                       "--add", "libunwind", "libcxxabi",
                                       "--remove", "clang", "libcxx",
                                       "--add", "compiler-rt",
                                       "--remove", "libcxxabi"])
        self.assertRegexpMatches(output,
                                 "Projects linked:.*\n" +
                                 ".*clang.*\n" +
                                 ".*compiler-rt.*\n" +
                                 ".*libcxx.*\n")

        output = self.run_with_output(["python", self.script, "projects",
                                       "--add", "libcxx", "--remove", "lld",
                                       "--add", "lld", "--remove", "libcxx"])
        self.assertRegexpMatches(output,
                                 "Projects linked:.*\n" +
                                 ".*clang.*\n" +
                                 ".*compiler-rt.*\n" +
                                 ".*lld.*\n")