bears.tests.vcs.git.GitCommitBearTest

Complexity

Total Complexity

14

Size/Duplication

Total Lines	138
Duplicated Lines	0 %

11 Methods

Rating	Name	Duplication	Size	Complexity
A	test_empty_message()	0	10	1
A	test_good_commit_messages()	0	19	1
A	run_git_command()	0	3	1
A	test_shortlog_checks()	0	14	1
A	setUp()	0	8	1
A	run_uut()	0	10	2
A	test_check_prerequisites()	0	11	3
A	git_commit()	0	7	1
A	tearDown()	0	3	1
B	test_body_checks()	0	31	1
A	test_git_failure()	0	9	1

from queue import Queue
from tempfile import mkdtemp
import os
import sys
import shutil
import unittest

sys.path.insert(0, ".")
from coalib.misc.Shell import prepare_string_argument, run_shell_command
from coalib.settings.Section import Section
from bears.vcs.git.GitCommitBear import GitCommitBear
from bears.tests.BearTestHelper import generate_skip_decorator


@generate_skip_decorator(GitCommitBear)
class GitCommitBearTest(unittest.TestCase):

    @staticmethod
    def run_git_command(*args):
        run_shell_command(" ".join(("git",) + args))

    @staticmethod
    def git_commit(msg):
        GitCommitBearTest.run_git_command("commit",
                                          "--allow-empty",
                                          "--allow-empty-message",
                                          "-m",
                                          prepare_string_argument(msg))

    def run_uut(self, *args, **kwargs):
        """
        Runs the unit-under-test (via `self.uut.run()`) and collects the
        messages of the yielded results as a list.

        :param args:   Positional arguments to forward to the run function.
        :param kwargs: Keyword arguments to forward to the run function.
        :return:       A list of the message strings.
        """
        return list(result.message for result in self.uut.run(*args, **kwargs))

    def setUp(self):
        self.msg_queue = Queue()
        self.uut = GitCommitBear(None, Section(""), self.msg_queue)

        self._old_cwd = os.getcwd()
        self.gitdir = mkdtemp()
        os.chdir(self.gitdir)
        self.run_git_command("init")

    def tearDown(self):
        os.chdir(self._old_cwd)
        shutil.rmtree(self.gitdir)

    def test_check_prerequisites(self):
        _shutil_which = shutil.which
        try:
            shutil.which = lambda *args, **kwargs: None
            self.assertEqual(GitCommitBear.check_prerequisites(),
                             "git is not installed.")

            shutil.which = lambda *args, **kwargs: "path/to/git"
            self.assertTrue(GitCommitBear.check_prerequisites())
        finally:
            shutil.which = _shutil_which

    def test_good_commit_messages(self):
        self.git_commit("A little nice commit")
        self.assertEqual(self.run_uut(), [])
        self.assertTrue(self.msg_queue.empty())

        self.git_commit("Commits messages that nearly exceeds default limit")
        self.assertEqual(self.run_uut(), [])
        self.assertTrue(self.msg_queue.empty())

        self.git_commit("Commits message with a body\n\nBody\nAnother body")
        self.assertEqual(self.run_uut(), [])
        self.assertTrue(self.msg_queue.empty())

        self.git_commit(
            "Commits message with a body\n\n"
            "nearly exceeding the default length of a body, but not quite. "
            "haaaaaaands")
        self.assertEqual(self.run_uut(), [])
        self.assertTrue(self.msg_queue.empty())

    def test_git_failure(self):
        # In this case use a reference to a non-existing commit, so just try
        # to log all commits on a newly created repository.
        self.assertEqual(self.run_uut(), [])

        git_error = self.msg_queue.get().message
        self.assertEqual(git_error[:4], "git:")

        self.assertTrue(self.msg_queue.empty())

    def test_empty_message(self):
        self.git_commit("")

        self.assertEqual(self.run_uut(),
                         ["HEAD commit has no message."])
        self.assertTrue(self.msg_queue.empty())

        self.assertEqual(self.run_uut(allow_empty_commit_message=True),
                         [])
        self.assertTrue(self.msg_queue.empty())

    def test_shortlog_checks(self):
        self.git_commit("This is a shortlog")

        self.assertEqual(self.run_uut(), [])
        self.assertTrue(self.msg_queue.empty())

        self.assertEqual(self.run_uut(shortlog_length=17),
                         ["Shortlog of HEAD commit is too long."])
        self.assertTrue(self.msg_queue.empty())

        self.git_commit("A shortlog that is too long is not good for history")
        self.assertEqual(self.run_uut(),
                         ["Shortlog of HEAD commit is too long."])
        self.assertTrue(self.msg_queue.empty())

    def test_body_checks(self):
        self.git_commit("Shortlog\n\nBody with details.")

        self.assertEqual(self.run_uut(), [])
        self.assertTrue(self.msg_queue.empty())

        self.git_commit("Shortlog only")

        self.assertEqual(self.run_uut(), [])
        self.assertTrue(self.msg_queue.empty())

        # Force a body.
        self.git_commit("Shortlog only ...")
        self.assertEqual(self.run_uut(force_body=True),
                         ["No commit message body at HEAD."])
        self.assertTrue(self.msg_queue.empty())

        # Miss a newline between shortlog and body.
        self.git_commit("Shortlog\nOops, body too early")
        self.assertEqual(self.run_uut(),
                         ["No newline between shortlog and body at HEAD."])
        self.assertTrue(self.msg_queue.empty())

        # And now too long lines.
        self.git_commit("Shortlog\n\n"
                        "This line is ok.\n"
                        "This line is by far too long (in this case).\n"
                        "This one too, blablablablablablablablabla.")
        self.assertEqual(self.run_uut(body_line_length=41),
                         ["Body of HEAD commit contains too long lines."])
        self.assertTrue(self.msg_queue.empty())


if __name__ == '__main__':
    unittest.main(verbosity=2)