coala-analyzer / coala

coalib/tests/coalaTest.py

import sys
import os
import unittest
import re
import tempfile
import subprocess

if sys.version_info < (3, 4):
    import imp as importlib

Unused imp imported as importlib

else:
    import importlib

The import importlib seems to be unused.

sys.path.insert(0, ".")
from coalib.misc.ContextManagers import retrieve_stdout

Unused retrieve_stdout imported from coalib.misc.ContextManagers

from coalib import coala_ci

Unused coala_ci imported from coalib

from coalib.settings import ConfigurationGathering

Unused ConfigurationGathering imported from coalib.settings

from coalib.output.Tagging import get_tag_path


def execute_coala_ci(args):
    """
    Executes the coala-ci main function with the given argument string.

    :param args: A list of arguments to pass to coala.
    :return:     A tuple holding the return value first and the stdout output
                 as second element.
    """
    stdout_file = tempfile.TemporaryFile()
    proc = subprocess.Popen([sys.executable, "-m",  "coala.coala_ci"] +

Exactly one space required after comma
proc = subprocess.Popen([sys.executable, "-m", "coala.coala_ci"] +
^

                            list(args),
                            stdout=stdout_file,
                            stderr=subprocess.STDOUT)
    retval = proc.wait()
    stdout_file.seek(0)
    output = stdout_file.read().decode(sys.stdout.encoding,
                                       errors="replace")
    return retval, output


class coalaTest(unittest.TestCase):

    def setUp(self):
        self.old_argv = sys.argv
        self.unescaped_coafile = os.path.abspath("./.coafile")
        self.coafile = re.escape(self.unescaped_coafile)

    def tearDown(self):
        sys.argv = self.old_argv

    def test_nonexistent(self):
        retval, output = execute_coala_ci(("-c", "nonex", "test"))
        self.assertRegex(
            output,
            ".*\\[ERROR\\].*The requested coafile '.*' does not exist.\n")

    def test_find_no_issues(self):
        retval, output = execute_coala_ci(('docs', '-c', self.coafile))
        self.assertRegex(output,
                         "(.*Unable to collect bears from.*PyLintBear.*)?",
                         "coala-ci output should be empty when running "
                         "over its own code.")
        self.assertEqual(retval,
                         0,
                         "coala-ci must return zero when running over its "
                         "own code.")

    def test_find_issues(self):
        retval, output = execute_coala_ci(("todos", "-c", self.coafile))
        self.assertRegex(output,
                         "(.*Unable to collect bears from.*PyLintBear.*)?",
                         "coala-ci output should be empty when running "
                         "over its own code. (Target section: todos)")
        self.assertNotEqual(retval,
                            0,
                            "coala-ci must return nonzero when running over "
                            "its own code. (Target section: todos)")

    def test_tagging(self):
        execute_coala_ci(('docs', "-S", "tag=test_tag", "-c", self.coafile))
        tag_path = get_tag_path("test_tag", self.unescaped_coafile)
        self.assertTrue(os.path.exists(tag_path))
        execute_coala_ci(('docs', "-S", "dtag=test_tag", "-c", self.coafile))
        self.assertFalse(os.path.exists(tag_path))

    def test_fail_acquire_settings(self):
        retval, output = execute_coala_ci((
            "-b", 'SpaceConsistencyBear', '-c', os.devnull))
        self.assertIn("During execution, we found that some", output)


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