coalib.tests.output.SomeBear - Code Metrics - Inspection of "ConsoleInteraction: Revalidate actions when someth..." - coala-analyzer/coala - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1626)

by Abdeali

created 2016-02-21 14:53 UTC

coalib.tests.output.SomeBear A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	7
Duplicated Lines	0 %

Metric	Value
dl	0
loc	7
rs	10
wmc	1

import os
import unittest
from collections import OrderedDict
from os.path import abspath, relpath

from pyprint.ConsolePrinter import ConsolePrinter
from pyprint.NullPrinter import NullPrinter

from coalib.bears.Bear import Bear
from coalib.misc.ContextManagers import (
    make_temp, retrieve_stdout, simulate_console_inputs)
from coalib.output.ConsoleInteraction import (
    acquire_actions_and_apply, acquire_settings, get_action_info, nothing_done,
    print_affected_files, print_bears, print_result, print_results,
    print_results_formatted, print_results_no_input, print_section_beginning,
    show_bears)
from coalib.output.printers.LogPrinter import LogPrinter
from coalib.output.printers.StringPrinter import StringPrinter
from coalib.results.Diff import Diff
from coalib.results.Result import Result
from coalib.results.result_actions.ApplyPatchAction import ApplyPatchAction
from coalib.results.result_actions.OpenEditorAction import OpenEditorAction
from coalib.results.result_actions.ResultAction import ResultAction
from coalib.results.SourceRange import SourceRange
from coalib.settings.Section import Section
from coalib.settings.Setting import Setting

STR_GET_VAL_FOR_SETTING = ("Please enter a value for the setting \"{}\" ({}) "
                           "needed by {}: ")
STR_LINE_DOESNT_EXIST = ("The line belonging to the following result "
                         "cannot be printed because it refers to a line "
                         "that doesn't seem to exist in the given file.")
STR_PROJECT_WIDE = "Project wide:"


class TestAction(ResultAction):

    def apply(self, result, original_file_dict, file_diff_dict, param):
        pass


class TestBear(Bear):

    def run(self, setting1, setting2: int=None):
        """
        Test bear Description.

        :param setting1: Required Setting.
        :param setting2: Optional Setting.
        """
        return None


class TestBear2(Bear):

    def run(self, setting1):
        """
        Test bear 2 description.

        :param setting1: Required Setting.
        """
        return None


class SomeBear(Bear):

    def run(self):
        """
        Some Description.
        """
        return None


class SomeOtherBear(Bear):

    def run(self, setting: int=None):
        """
        This is a Bear.
        :param setting: This is an optional setting.
        """
        setting = 1
        return None


class SomeglobalBear(Bear):

    def run(self):
        """
        Some global-bear Description.
        """
        return None


class SomelocalBear(Bear):

    def run(self):
        """
        Some local-bear Description.
        """
        return None


class ConsoleInteractionTest(unittest.TestCase):

    def setUp(self):
        self.log_printer = LogPrinter(ConsolePrinter(print_colored=False))
        self.console_printer = ConsolePrinter(print_colored=False)
        self.file_diff_dict = {}
        self.local_bears = OrderedDict([("default", [SomelocalBear]),
                                        ("test", [SomelocalBear])])
        self.global_bears = OrderedDict([("default", [SomeglobalBear]),
                                         ("test", [SomeglobalBear])])

        self.old_open_editor_applicable = OpenEditorAction.is_applicable
        OpenEditorAction.is_applicable = staticmethod(lambda *args: False)

        self.old_apply_patch_applicable = ApplyPatchAction.is_applicable
        ApplyPatchAction.is_applicable = staticmethod(lambda *args: False)

    def tearDown(self):
        OpenEditorAction.is_applicable = self.old_open_editor_applicable
        ApplyPatchAction.is_applicable = self.old_apply_patch_applicable

    def test_require_settings(self):
        self.assertRaises(TypeError, acquire_settings, self.log_printer, 0)
        self.assertEqual(acquire_settings(self.log_printer, {0: 0}), {})

        with simulate_console_inputs(0, 1, 2) as generator:
            self.assertEqual(acquire_settings(self.log_printer,
                                              {"setting": ["help text",
                                                           "SomeBear"]}),
                             {"setting": 0})

            self.assertEqual(acquire_settings(self.log_printer,
                                              {"setting": ["help text",
                                                           "SomeBear",
                                                           "AnotherBear"]}),
                             {"setting": 1})

            self.assertEqual(acquire_settings(self.log_printer,
                                              {"setting": ["help text",
                                                           "SomeBear",
                                                           "AnotherBear",
                                                           "YetAnotherBear"]}),
                             {"setting": 2})

            self.assertEqual(generator.last_input, 2)

    def test_print_result(self):
        print_result(self.console_printer,
                     self.log_printer,
                     None,
                     self.file_diff_dict,
                     "illegal value",
                     {})

        with simulate_console_inputs(0):
            print_result(self.console_printer,
                         self.log_printer,
                         None,
                         self.file_diff_dict,
                         Result("origin", "msg", diffs={}),
                         {})

        with make_temp() as testfile_path:
            file_dict = {
                testfile_path: ["1\n", "2\n", "3\n"],
                "f_b": ["1", "2", "3"]
            }
            diff = Diff(file_dict[testfile_path])
            diff.delete_line(2)
            diff.change_line(3, "3\n", "3_changed\n")

            with simulate_console_inputs(1), self.assertRaises(ValueError):
                ApplyPatchAction.is_applicable = staticmethod(
                    lambda *args: True)
                print_result(self.console_printer,
                             self.log_printer,
                             None,
                             self.file_diff_dict,
                             Result("origin", "msg", diffs={
                                    testfile_path: diff}),
                             file_dict)

            # Interaction must be closed by the user with `0` if it's not a
            # param
            with simulate_console_inputs("INVALID",
                                         -1,
                                         1,
                                         0,
                                         3) as input_generator:
                curr_section = Section("")
                print_section_beginning(self.console_printer, curr_section)
                print_result(self.console_printer,
                             self.log_printer,
                             curr_section,
                             self.file_diff_dict,
                             Result("origin", "msg", diffs={
                                    testfile_path: diff}),
                             file_dict)
                self.assertEqual(input_generator.last_input, 3)

                self.file_diff_dict.clear()

                with open(testfile_path) as f:
                    self.assertEqual(f.readlines(), ["1\n", "3_changed\n"])

                os.remove(testfile_path + ".orig")

                name, section = get_action_info(curr_section,
                                                TestAction().get_metadata())
                self.assertEqual(input_generator.last_input, 4)
                self.assertEqual(str(section), " {param : '3'}")
                self.assertEqual(name, "TestAction")

        # Check if the user is asked for the parameter only the first time.
        # Use OpenEditorAction that needs this parameter (editor command).
        with simulate_console_inputs(1, "test_editor", 0, 1, 0) as generator:
            OpenEditorAction.is_applicable = staticmethod(lambda *args: True)

            patch_result = Result("origin", "msg", diffs={testfile_path: diff})
            patch_result.file = "f_b"

            print_result(self.console_printer,
                         self.log_printer,
                         curr_section,
                         self.file_diff_dict,
                         patch_result,
                         file_dict)
            # choose action, choose editor, choose no action (-1 -> 2)
            self.assertEqual(generator.last_input, 2)

            # It shoudn't ask for parameter again
            print_result(self.console_printer,
                         self.log_printer,
                         curr_section,
                         self.file_diff_dict,
                         patch_result,
                         file_dict)
            self.assertEqual(generator.last_input, 4)

    def test_print_affected_files(self):
        with retrieve_stdout() as stdout, \
             make_temp() as some_file:
            file_dict = {some_file: ["1\n", "2\n", "3\n"]}
            affected_code = (SourceRange.from_values(some_file),)
            print_affected_files(self.console_printer,
                                 self.log_printer,
                                 Section(""),
                                 Result("origin",
                                        "message",
                                        affected_code=affected_code),
                                 file_dict,
                                 color=True)
            self.assertEqual(stdout.getvalue(),
                             "\n"+relpath(some_file)+"\n")

    def test_acquire_actions_and_apply(self):
        with make_temp() as testfile_path:
            file_dict = {testfile_path: ["1\n", "2\n", "3\n"]}
            diff = Diff(file_dict[testfile_path])
            diff.delete_line(2)
            diff.change_line(3, "3\n", "3_changed\n")
            with simulate_console_inputs(1, 0) as generator, \
                    retrieve_stdout() as sio:
                ApplyPatchAction.is_applicable = staticmethod(
                        lambda *args: True)
                acquire_actions_and_apply(self.console_printer,
                                          self.log_printer,
                                          Section(""),
                                          self.file_diff_dict,
                                          Result("origin", "message", diffs={
                                           testfile_path: diff}),
                                          file_dict)
                self.assertEqual(generator.last_input, 1)
                self.assertIn(ApplyPatchAction.success_message, sio.getvalue())

            class InvalidateTestAction(ResultAction):

                is_applicable = staticmethod(lambda *args: True)

                def apply(*args, **kwargs):
                    ApplyPatchAction.is_applicable = staticmethod(
                        lambda *args: False)

            old_applypatch_is_applicable = ApplyPatchAction.is_applicable
            ApplyPatchAction.is_applicable = staticmethod(lambda *args: True)
            cli_actions = [ApplyPatchAction(), InvalidateTestAction()]

            with simulate_console_inputs(2, 1, 0) as generator, \
                    retrieve_stdout() as sio:
                acquire_actions_and_apply(self.console_printer,
                                          self.log_printer,
                                          Section(""),
                                          self.file_diff_dict,
                                          Result("origin", "message",
                                                 diffs={testfile_path: diff}),
                                          file_dict,
                                          cli_actions=cli_actions)
                self.assertEqual(generator.last_input, 2)

                action_fail = "Failed to execute the action"
                self.assertNotIn(action_fail, sio.getvalue())

                apply_path_desc = ApplyPatchAction().get_metadata().desc
                self.assertEqual(sio.getvalue().count(apply_path_desc), 1)

            ApplyPatchAction.is_applicable = old_applypatch_is_applicable

    def test_print_result_no_input(self):
        with make_temp() as testfile_path:
            file_dict = {testfile_path: ["1\n", "2\n", "3\n"]}
            diff = Diff(file_dict[testfile_path])
            diff.delete_line(2)
            diff.change_line(3, "3\n", "3_changed\n")
            with simulate_console_inputs(1, 2, 3) as generator, \
                    retrieve_stdout() as stdout:
                ApplyPatchAction.is_applicable = staticmethod(
                      lambda *args: True)
                print_results_no_input(self.log_printer,
                                       Section("someSection"),
                                       [Result("origin", "message", diffs={
                                           testfile_path: diff})],
                                       file_dict,
                                       self.file_diff_dict,
                                       color=False)
                self.assertEqual(generator.last_input, -1)
                self.assertEqual(stdout.getvalue(),
                                 """
Project wide:
|    | [NORMAL] origin:
|    | message
""")

    def test_print_section_beginning(self):
        with retrieve_stdout() as stdout:
            print_section_beginning(self.console_printer, Section("name"))
            self.assertEqual(stdout.getvalue(), "Executing section name...\n")

    def test_nothing_done(self):
        with retrieve_stdout() as stdout:
            nothing_done(self.log_printer)
            self.assertIn("No existent section was targeted or enabled. "
                          "Nothing to do.\n",
                          stdout.getvalue())

    def test_print_results_empty(self):
        with retrieve_stdout() as stdout:
            print_results(self.log_printer, Section(""), [], {}, {})
            self.assertEqual(stdout.getvalue(), "")

    def test_print_results_project_wide(self):
        with retrieve_stdout() as stdout:
            print_results(self.log_printer,
                          Section(""),
                          [Result("origin", "message")],
                          {},
                          {},
                          color=False)
            self.assertEqual(
                "\n{}\n|    | [NORMAL] origin:\n|    | message"
                "\n".format(STR_PROJECT_WIDE),
                stdout.getvalue())

    def test_print_results_for_file(self):
        with retrieve_stdout() as stdout:
            print_results(
                self.log_printer,
                Section(""),
                [Result.from_values("SpaceConsistencyBear",
                                    "Trailing whitespace found",
                                    file="filename",
                                    line=2)],
                {abspath("filename"): ["test line\n", "line 2\n", "line 3\n"]},
                {},
                color=False)
            self.assertEqual("""\nfilename
|   2| line 2
|    | [NORMAL] SpaceConsistencyBear:
|    | Trailing whitespace found
""",
                             stdout.getvalue())

        with retrieve_stdout() as stdout:
            print_results(
                self.log_printer,
                Section(""),
                [Result.from_values("SpaceConsistencyBear",
                                    "Trailing whitespace found",
                                    file="filename",
                                    line=5)],
                {abspath("filename"): ["test line\n",
                                       "line 2\n",
                                       "line 3\n",
                                       "line 4\n",
                                       "line 5\n"]},
                {},
                color=False)
            self.assertEqual("""\nfilename
|   5| line 5
|    | [NORMAL] SpaceConsistencyBear:
|    | Trailing whitespace found
""",
                             stdout.getvalue())

    def test_print_results_sorting(self):
        with retrieve_stdout() as stdout:
            print_results(self.log_printer,
                          Section(""),
                          [Result.from_values("SpaceConsistencyBear",
                                              "Trailing whitespace found",
                                              file="file",
                                              line=5),
                           Result.from_values("SpaceConsistencyBear",
                                              "Trailing whitespace found",
                                              file="file",
                                              line=2)],
                          {abspath("file"): ["test line\n",
                                             "line 2\n",
                                             "line 3\n",
                                             "line 4\n",
                                             "line 5\n"]},
                          {},
                          color=False)

            self.assertEqual("""
file
|   2| line 2
|    | [NORMAL] SpaceConsistencyBear:
|    | Trailing whitespace found

file
|   5| line 5
|    | [NORMAL] SpaceConsistencyBear:
|    | Trailing whitespace found
""",
                             stdout.getvalue())

    def test_print_results_multiple_ranges(self):
        affected_code = (
            SourceRange.from_values("some_file", 5, end_line=7),
            SourceRange.from_values("another_file", 1, 3, 1, 5),
            SourceRange.from_values("another_file", 3, 3, 3, 5))
        with retrieve_stdout() as stdout:
            print_results(
                self.log_printer,
                Section(""),
                [Result("ClangCloneDetectionBear",
                        "Clone Found",
                        affected_code)],
                {abspath("some_file"): ["line " + str(i + 1) + "\n"
                                        for i in range(10)],
                 abspath("another_file"): ["line " + str(i + 1) + "\n"
                                           for i in range(10)]},
                {},
                color=False)
            self.assertEqual("""
another_file
|   1| line 1

another_file
|   3| line 3

some_file
|   5| line 5
|   6| line 6
|   7| line 7
|    | [NORMAL] ClangCloneDetectionBear:
|    | Clone Found
""",
                             stdout.getvalue())

    def test_print_results_missing_file(self):
        self.log_printer = LogPrinter(NullPrinter())
        with retrieve_stdout() as stdout:
            print_results(
                self.log_printer,
                Section(""),
                [Result("t", "msg"),
                 Result.from_values("t", "msg", file="file", line=5)],
                {},
                {},
                color=False)
            self.assertEqual("\n" + STR_PROJECT_WIDE + "\n"
                             "|    | [NORMAL] t:\n"
                             "|    | msg\n"
                             # Second results file isn't there, no context is
                             # printed, only a warning log message which we
                             # don't catch
                             "|    | [NORMAL] t:\n"
                             "|    | msg\n", stdout.getvalue())

    def test_print_results_missing_line(self):
        with retrieve_stdout() as stdout:
            print_results(
                self.log_printer,
                Section(""),
                [Result.from_values("t", "msg", file="file", line=5),
                 Result.from_values("t", "msg", file="file", line=6)],
                {abspath("file"): ["line " + str(i + 1) for i in range(5)]},
                {},
                color=False)
            self.assertEqual("\n"
                             "file\n"
                             "|   5| line 5\n"
                             "|    | [NORMAL] t:\n"
                             "|    | msg\n"
                             "\n"
                             "file\n"
                             "|    | {}\n"
                             "|    | [NORMAL] t:\n"
                             "|    | msg\n".format(STR_LINE_DOESNT_EXIST),
                             stdout.getvalue())

    def test_print_results_without_line(self):
        with retrieve_stdout() as stdout:
            print_results(
                self.log_printer,
                Section(""),
                [Result.from_values("t", "msg", file="file")],
                {abspath("file"): []},
                {},
                color=False)
            self.assertEqual(
                "\nfile\n"
                "|    | [NORMAL] t:\n"
                "|    | msg\n",
                stdout.getvalue())

    def test_print_bears_empty(self):
        with retrieve_stdout() as stdout:
            bears = {}
            print_bears(self.log_printer.printer, bears, True)
            self.assertEqual("No bears to show.\n", stdout.getvalue())
        with retrieve_stdout() as stdout:
            bears = {}
            print_bears(self.log_printer.printer, bears, False)
            self.assertEqual("No bears to show.\n", stdout.getvalue())

    def test_print_bears(self):
        with retrieve_stdout() as stdout:
            bears = {TestBear: ["default", "docs"]}
            print_bears(self.log_printer.printer, bears, False)
            expected_string = "TestBear:\n"
            expected_string += "  Test bear Description.\n\n"
            expected_string += "  Used in:\n"
            expected_string += "   * default\n"
            expected_string += "   * docs\n\n"
            expected_string += "  Needed Settings:\n"
            expected_string += "   * setting1: Required Setting.\n\n"
            expected_string += "  Optional Settings:\n"
            expected_string += "   * setting2: Optional Setting. ("
            expected_string += "Optional, defaults to 'None'."
            expected_string += ")\n\n"

            self.assertEqual(expected_string, stdout.getvalue())

    def test_print_bears_no_settings(self):
        with retrieve_stdout() as stdout:
            bears = {SomeBear: ["default"]}
            print_bears(self.log_printer.printer, bears, False)
            expected_string = "SomeBear:\n"
            expected_string += "  Some Description.\n\n"
            expected_string += "  Used in:\n"
            expected_string += "   * default\n\n"
            expected_string += "  No needed settings.\n\n"
            expected_string += "  No optional settings.\n\n"

            self.assertEqual(expected_string, stdout.getvalue())

    def test_print_bears_no_needed_settings(self):
        with retrieve_stdout() as stdout:
            bears = {SomeOtherBear: ["test"]}
            print_bears(self.log_printer.printer, bears, False)
            expected_string = "SomeOtherBear:\n"
            expected_string += "  This is a Bear.\n\n"
            expected_string += "  Used in:\n"
            expected_string += "   * test\n\n"
            expected_string += "  No needed settings.\n\n"
            expected_string += "  Optional Settings:\n"
            expected_string += "   * setting: This is an optional setting. ("
            expected_string += "Optional, defaults to 'None'."
            expected_string += ")\n\n"

            self.assertEqual(expected_string, stdout.getvalue())

    def test_print_bears_no_optional_settings(self):
        with retrieve_stdout() as stdout:
            bears = {TestBear2: ["test"]}
            print_bears(self.log_printer.printer, bears, False)
            expected_string = "TestBear2:\n"
            expected_string += "  Test bear 2 description.\n\n"
            expected_string += "  Used in:\n"
            expected_string += "   * test\n\n"
            expected_string += "  Needed Settings:\n"
            expected_string += "   * setting1: Required Setting.\n\n"
            expected_string += "  No optional settings.\n\n"

            self.assertEqual(expected_string, stdout.getvalue())

    def test_print_bears_no_sections(self):
        with retrieve_stdout() as stdout:
            bears = {SomeBear: []}
            print_bears(self.log_printer.printer, bears, False)
            expected_string = "SomeBear:\n"
            expected_string += "  Some Description.\n\n"
            expected_string += "  No sections.\n\n"
            expected_string += "  No needed settings.\n\n"
            expected_string += "  No optional settings.\n\n"

            self.assertEqual(expected_string, stdout.getvalue())

    def test_show_bears(self):
        with retrieve_stdout() as stdout:
            bears = {SomelocalBear: ['default', 'test'],
                     SomeglobalBear: ['default', 'test']}
            print_bears(self.log_printer.printer, bears, False)
            expected_string = stdout.getvalue()
        self.maxDiff = None
        with retrieve_stdout() as stdout:
            show_bears(self.local_bears,
                       self.global_bears,
                       False,
                       self.log_printer.printer)
            self.assertEqual(expected_string, stdout.getvalue())

        with retrieve_stdout() as stdout:
            show_bears(self.local_bears,
                       self.global_bears,
                       True,
                       self.log_printer.printer)
            self.assertEqual(" * SomeglobalBear\n"
                             " * SomelocalBear\n", stdout.getvalue())


# Own test because this is easy and not tied to the rest
class PrintFormattedResultsTest(unittest.TestCase):

    def setUp(self):
        self.printer = StringPrinter()
        self.logger = LogPrinter(self.printer)
        self.section = Section("t")

    def test_default_format(self):
        expected_string = ("id:-?[0-9]+:origin:1:file:None:from_line:None:"
                           "from_column:None:to_line:None:to_column:None:"
                           "severity:1:msg:2\n")
        with retrieve_stdout() as stdout:
            print_results_formatted(self.logger,
                                    self.section,
                                    [Result("1", "2")],
                                    None,
                                    None)
            self.assertRegex(stdout.getvalue(), expected_string)

    def test_multiple_ranges(self):
        expected_string = (
            "id:-?[0-9]+:origin:1:.*file:.*another_file:from_line:5:"
            "from_column:3:to_line:5:to_column:5:"
            "severity:1:msg:2\n"
            "id:-?[0-9]+:origin:1:.*file:.*some_file:from_line:5:"
            "from_column:None:to_line:7:to_column:None:"
            "severity:1:msg:2\n")
        affected_code = (SourceRange.from_values("some_file", 5, end_line=7),
                         SourceRange.from_values("another_file", 5, 3, 5, 5))
        with retrieve_stdout() as stdout:
            print_results_formatted(self.logger,
                                    self.section,
                                    [Result("1", "2", affected_code)],
                                    None,
                                    None)
            self.assertRegex(stdout.getvalue(), expected_string)

    def test_bad_format(self):
        self.section.append(Setting("format_str", "{nonexistant}"))
        print_results_formatted(self.logger,
                                self.section,
                                [Result("1", "2")],
                                None,
                                None)
        self.assertRegex(self.printer.string, ".*Unable to print.*")

    def test_good_format(self):
        self.section.append(Setting("format_str", "{origin}"))
        with retrieve_stdout() as stdout:
            print_results_formatted(self.logger,
                                    self.section,
                                    [Result("1", "2")],
                                    None,
                                    None)
            self.assertEqual(stdout.getvalue(), "1\n")

    def test_empty_list(self):
        self.section.append(Setting("format_str", "{origin}"))
        # Shouldn't attempt to format the string None and will fail badly if
        # its done wrong.
        print_results_formatted(None,
                                self.section,
                                [],
                                None,
                                None,
                                None)


1			import os
2			import unittest
3			from collections import OrderedDict
4			from os.path import abspath, relpath
5
6			from pyprint.ConsolePrinter import ConsolePrinter
7			from pyprint.NullPrinter import NullPrinter
8
9			from coalib.bears.Bear import Bear
10			from coalib.misc.ContextManagers import (
11			make_temp, retrieve_stdout, simulate_console_inputs)
12			from coalib.output.ConsoleInteraction import (
13			acquire_actions_and_apply, acquire_settings, get_action_info, nothing_done,
14			print_affected_files, print_bears, print_result, print_results,
15			print_results_formatted, print_results_no_input, print_section_beginning,
16			show_bears)
17			from coalib.output.printers.LogPrinter import LogPrinter
18			from coalib.output.printers.StringPrinter import StringPrinter
19			from coalib.results.Diff import Diff
20			from coalib.results.Result import Result
21			from coalib.results.result_actions.ApplyPatchAction import ApplyPatchAction
22			from coalib.results.result_actions.OpenEditorAction import OpenEditorAction
23			from coalib.results.result_actions.ResultAction import ResultAction
24			from coalib.results.SourceRange import SourceRange
25			from coalib.settings.Section import Section
26			from coalib.settings.Setting import Setting
27
28			STR_GET_VAL_FOR_SETTING = ("Please enter a value for the setting \"{}\" ({}) "
29			"needed by {}: ")
30			STR_LINE_DOESNT_EXIST = ("The line belonging to the following result "
31			"cannot be printed because it refers to a line "
32			"that doesn't seem to exist in the given file.")
33			STR_PROJECT_WIDE = "Project wide:"
34
35
36			class TestAction(ResultAction):
37
38			def apply(self, result, original_file_dict, file_diff_dict, param):
39			pass
40
41
42			class TestBear(Bear):
43
44			def run(self, setting1, setting2: int=None):
45			"""
46			Test bear Description.
47
48			:param setting1: Required Setting.
49			:param setting2: Optional Setting.
50			"""
51			return None
52
53
54			class TestBear2(Bear):
55
56			def run(self, setting1):
57			"""
58			Test bear 2 description.
59
60			:param setting1: Required Setting.
61			"""
62			return None
63
64
65			class SomeBear(Bear):
66
67			def run(self):
68			"""
69			Some Description.
70			"""
71			return None
72
73
74			class SomeOtherBear(Bear):
75
76			def run(self, setting: int=None):
77			"""
78			This is a Bear.
79			:param setting: This is an optional setting.
80			"""
81			setting = 1
82			return None
83
84
85			class SomeglobalBear(Bear):
86
87			def run(self):
88			"""
89			Some global-bear Description.
90			"""
91			return None
92
93
94			class SomelocalBear(Bear):
95
96			def run(self):
97			"""
98			Some local-bear Description.
99			"""
100			return None
101
102
103			class ConsoleInteractionTest(unittest.TestCase):
104
105			def setUp(self):
106			self.log_printer = LogPrinter(ConsolePrinter(print_colored=False))
107			self.console_printer = ConsolePrinter(print_colored=False)
108			self.file_diff_dict = {}
109			self.local_bears = OrderedDict([("default", [SomelocalBear]),
110			("test", [SomelocalBear])])
111			self.global_bears = OrderedDict([("default", [SomeglobalBear]),
112			("test", [SomeglobalBear])])
113
114			self.old_open_editor_applicable = OpenEditorAction.is_applicable
115			OpenEditorAction.is_applicable = staticmethod(lambda *args: False)
116
117			self.old_apply_patch_applicable = ApplyPatchAction.is_applicable
118			ApplyPatchAction.is_applicable = staticmethod(lambda *args: False)
119
120			def tearDown(self):
121			OpenEditorAction.is_applicable = self.old_open_editor_applicable
122			ApplyPatchAction.is_applicable = self.old_apply_patch_applicable
123
124			def test_require_settings(self):
125			self.assertRaises(TypeError, acquire_settings, self.log_printer, 0)
126			self.assertEqual(acquire_settings(self.log_printer, {0: 0}), {})
127
128			with simulate_console_inputs(0, 1, 2) as generator:
129			self.assertEqual(acquire_settings(self.log_printer,
130			{"setting": ["help text",
131			"SomeBear"]}),
132			{"setting": 0})
133
134			self.assertEqual(acquire_settings(self.log_printer,
135			{"setting": ["help text",
136			"SomeBear",
137			"AnotherBear"]}),
138			{"setting": 1})
139
140			self.assertEqual(acquire_settings(self.log_printer,
141			{"setting": ["help text",
142			"SomeBear",
143			"AnotherBear",
144			"YetAnotherBear"]}),
145			{"setting": 2})
146
147			self.assertEqual(generator.last_input, 2)
148
149			def test_print_result(self):
150			print_result(self.console_printer,
151			self.log_printer,
152			None,
153			self.file_diff_dict,
154			"illegal value",
155			{})
156
157			with simulate_console_inputs(0):
158			print_result(self.console_printer,
159			self.log_printer,
160			None,
161			self.file_diff_dict,
162			Result("origin", "msg", diffs={}),
163			{})
164
165			with make_temp() as testfile_path:
166			file_dict = {
167			testfile_path: ["1\n", "2\n", "3\n"],
168			"f_b": ["1", "2", "3"]
169			}
170			diff = Diff(file_dict[testfile_path])
171			diff.delete_line(2)
172			diff.change_line(3, "3\n", "3_changed\n")
173
174			with simulate_console_inputs(1), self.assertRaises(ValueError):
175			ApplyPatchAction.is_applicable = staticmethod(
176			lambda *args: True)
177			print_result(self.console_printer,
178			self.log_printer,
179			None,
180			self.file_diff_dict,
181			Result("origin", "msg", diffs={
182			testfile_path: diff}),
183			file_dict)
184
185			# Interaction must be closed by the user with `0` if it's not a
186			# param
187			with simulate_console_inputs("INVALID",
188			-1,
189			1,
190			0,
191			3) as input_generator:
192			curr_section = Section("")
193			print_section_beginning(self.console_printer, curr_section)
194			print_result(self.console_printer,
195			self.log_printer,
196			curr_section,
197			self.file_diff_dict,
198			Result("origin", "msg", diffs={
199			testfile_path: diff}),
200			file_dict)
201			self.assertEqual(input_generator.last_input, 3)
202
203			self.file_diff_dict.clear()
204
205			with open(testfile_path) as f:
206			self.assertEqual(f.readlines(), ["1\n", "3_changed\n"])
207
208			os.remove(testfile_path + ".orig")
209
210			name, section = get_action_info(curr_section,
211			TestAction().get_metadata())
212			self.assertEqual(input_generator.last_input, 4)
213			self.assertEqual(str(section), " {param : '3'}")
214			self.assertEqual(name, "TestAction")
215
216			# Check if the user is asked for the parameter only the first time.
217			# Use OpenEditorAction that needs this parameter (editor command).
218			with simulate_console_inputs(1, "test_editor", 0, 1, 0) as generator:
219			OpenEditorAction.is_applicable = staticmethod(lambda *args: True)
220
221			patch_result = Result("origin", "msg", diffs={testfile_path: diff})
222			patch_result.file = "f_b"
223
224			print_result(self.console_printer,
225			self.log_printer,
226			curr_section,
227			self.file_diff_dict,
228			patch_result,
229			file_dict)
230			# choose action, choose editor, choose no action (-1 -> 2)
231			self.assertEqual(generator.last_input, 2)
232
233			# It shoudn't ask for parameter again
234			print_result(self.console_printer,
235			self.log_printer,
236			curr_section,
237			self.file_diff_dict,
238			patch_result,
239			file_dict)
240			self.assertEqual(generator.last_input, 4)
241
242			def test_print_affected_files(self):
243			with retrieve_stdout() as stdout, \
244			make_temp() as some_file:
245			file_dict = {some_file: ["1\n", "2\n", "3\n"]}
246			affected_code = (SourceRange.from_values(some_file),)
247			print_affected_files(self.console_printer,
248			self.log_printer,
249			Section(""),
250			Result("origin",
251			"message",
252			affected_code=affected_code),
253			file_dict,
254			color=True)
255			self.assertEqual(stdout.getvalue(),
256			"\n"+relpath(some_file)+"\n")
257
258			def test_acquire_actions_and_apply(self):
259			with make_temp() as testfile_path:
260			file_dict = {testfile_path: ["1\n", "2\n", "3\n"]}
261			diff = Diff(file_dict[testfile_path])
262			diff.delete_line(2)
263			diff.change_line(3, "3\n", "3_changed\n")
264			with simulate_console_inputs(1, 0) as generator, \
265			retrieve_stdout() as sio:
266			ApplyPatchAction.is_applicable = staticmethod(
267			lambda *args: True)
268			acquire_actions_and_apply(self.console_printer,
269			self.log_printer,
270			Section(""),
271			self.file_diff_dict,
272			Result("origin", "message", diffs={
273			testfile_path: diff}),
274			file_dict)
275			self.assertEqual(generator.last_input, 1)
276			self.assertIn(ApplyPatchAction.success_message, sio.getvalue())
277
278			class InvalidateTestAction(ResultAction):
279
280			is_applicable = staticmethod(lambda *args: True)
281
282			def apply(args, *kwargs):
283			ApplyPatchAction.is_applicable = staticmethod(
284			lambda *args: False)
285
286			old_applypatch_is_applicable = ApplyPatchAction.is_applicable
287			ApplyPatchAction.is_applicable = staticmethod(lambda *args: True)
288			cli_actions = [ApplyPatchAction(), InvalidateTestAction()]
289
290			with simulate_console_inputs(2, 1, 0) as generator, \
291			retrieve_stdout() as sio:
292			acquire_actions_and_apply(self.console_printer,
293			self.log_printer,
294			Section(""),
295			self.file_diff_dict,
296			Result("origin", "message",
297			diffs={testfile_path: diff}),
298			file_dict,
299			cli_actions=cli_actions)
300			self.assertEqual(generator.last_input, 2)
301
302			action_fail = "Failed to execute the action"
303			self.assertNotIn(action_fail, sio.getvalue())
304
305			apply_path_desc = ApplyPatchAction().get_metadata().desc
306			self.assertEqual(sio.getvalue().count(apply_path_desc), 1)
307
308			ApplyPatchAction.is_applicable = old_applypatch_is_applicable
309
310			def test_print_result_no_input(self):
311			with make_temp() as testfile_path:
312			file_dict = {testfile_path: ["1\n", "2\n", "3\n"]}
313			diff = Diff(file_dict[testfile_path])
314			diff.delete_line(2)
315			diff.change_line(3, "3\n", "3_changed\n")
316			with simulate_console_inputs(1, 2, 3) as generator, \
317			retrieve_stdout() as stdout:
318			ApplyPatchAction.is_applicable = staticmethod(
319			lambda *args: True)
320			print_results_no_input(self.log_printer,
321			Section("someSection"),
322			[Result("origin", "message", diffs={
323			testfile_path: diff})],
324			file_dict,
325			self.file_diff_dict,
326			color=False)
327			self.assertEqual(generator.last_input, -1)
328			self.assertEqual(stdout.getvalue(),
329			"""
330			Project wide:
331			\| \| [NORMAL] origin:
332			\| \| message
333			""")
334
335			def test_print_section_beginning(self):
336			with retrieve_stdout() as stdout:
337			print_section_beginning(self.console_printer, Section("name"))
338			self.assertEqual(stdout.getvalue(), "Executing section name...\n")
339
340			def test_nothing_done(self):
341			with retrieve_stdout() as stdout:
342			nothing_done(self.log_printer)
343			self.assertIn("No existent section was targeted or enabled. "
344			"Nothing to do.\n",
345			stdout.getvalue())
346
347			def test_print_results_empty(self):
348			with retrieve_stdout() as stdout:
349			print_results(self.log_printer, Section(""), [], {}, {})
350			self.assertEqual(stdout.getvalue(), "")
351
352			def test_print_results_project_wide(self):
353			with retrieve_stdout() as stdout:
354			print_results(self.log_printer,
355			Section(""),
356			[Result("origin", "message")],
357			{},
358			{},
359			color=False)
360			self.assertEqual(
361			"\n{}\n\| \| [NORMAL] origin:\n\| \| message"
362			"\n".format(STR_PROJECT_WIDE),
363			stdout.getvalue())
364
365			def test_print_results_for_file(self):
366			with retrieve_stdout() as stdout:
367			print_results(
368			self.log_printer,
369			Section(""),
370			[Result.from_values("SpaceConsistencyBear",
371			"Trailing whitespace found",
372			file="filename",
373			line=2)],
374			{abspath("filename"): ["test line\n", "line 2\n", "line 3\n"]},
375			{},
376			color=False)
377			self.assertEqual("""\nfilename
378			\| 2\| line 2
379			\| \| [NORMAL] SpaceConsistencyBear:
380			\| \| Trailing whitespace found
381			""",
382			stdout.getvalue())
383
384			with retrieve_stdout() as stdout:
385			print_results(
386			self.log_printer,
387			Section(""),
388			[Result.from_values("SpaceConsistencyBear",
389			"Trailing whitespace found",
390			file="filename",
391			line=5)],
392			{abspath("filename"): ["test line\n",
393			"line 2\n",
394			"line 3\n",
395			"line 4\n",
396			"line 5\n"]},
397			{},
398			color=False)
399			self.assertEqual("""\nfilename
400			\| 5\| line 5
401			\| \| [NORMAL] SpaceConsistencyBear:
402			\| \| Trailing whitespace found
403			""",
404			stdout.getvalue())
405
406			def test_print_results_sorting(self):
407			with retrieve_stdout() as stdout:
408			print_results(self.log_printer,
409			Section(""),
410			[Result.from_values("SpaceConsistencyBear",
411			"Trailing whitespace found",
412			file="file",
413			line=5),
414			Result.from_values("SpaceConsistencyBear",
415			"Trailing whitespace found",
416			file="file",
417			line=2)],
418			{abspath("file"): ["test line\n",
419			"line 2\n",
420			"line 3\n",
421			"line 4\n",
422			"line 5\n"]},
423			{},
424			color=False)
425
426			self.assertEqual("""
427			file
428			\| 2\| line 2
429			\| \| [NORMAL] SpaceConsistencyBear:
430			\| \| Trailing whitespace found
431
432			file
433			\| 5\| line 5
434			\| \| [NORMAL] SpaceConsistencyBear:
435			\| \| Trailing whitespace found
436			""",
437			stdout.getvalue())
438
439			def test_print_results_multiple_ranges(self):
440			affected_code = (
441			SourceRange.from_values("some_file", 5, end_line=7),
442			SourceRange.from_values("another_file", 1, 3, 1, 5),
443			SourceRange.from_values("another_file", 3, 3, 3, 5))
444			with retrieve_stdout() as stdout:
445			print_results(
446			self.log_printer,
447			Section(""),
448			[Result("ClangCloneDetectionBear",
449			"Clone Found",
450			affected_code)],
451			{abspath("some_file"): ["line " + str(i + 1) + "\n"
452			for i in range(10)],
453			abspath("another_file"): ["line " + str(i + 1) + "\n"
454			for i in range(10)]},
455			{},
456			color=False)
457			self.assertEqual("""
458			another_file
459			\| 1\| line 1
460
461			another_file
462			\| 3\| line 3
463
464			some_file
465			\| 5\| line 5
466			\| 6\| line 6
467			\| 7\| line 7
468			\| \| [NORMAL] ClangCloneDetectionBear:
469			\| \| Clone Found
470			""",
471			stdout.getvalue())
472
473			def test_print_results_missing_file(self):
474			self.log_printer = LogPrinter(NullPrinter())
475			with retrieve_stdout() as stdout:
476			print_results(
477			self.log_printer,
478			Section(""),
479			[Result("t", "msg"),
480			Result.from_values("t", "msg", file="file", line=5)],
481			{},
482			{},
483			color=False)
484			self.assertEqual("\n" + STR_PROJECT_WIDE + "\n"
485			"\| \| [NORMAL] t:\n"
486			"\| \| msg\n"
487			# Second results file isn't there, no context is
488			# printed, only a warning log message which we
489			# don't catch
490			"\| \| [NORMAL] t:\n"
491			"\| \| msg\n", stdout.getvalue())
492
493			def test_print_results_missing_line(self):
494			with retrieve_stdout() as stdout:
495			print_results(
496			self.log_printer,
497			Section(""),
498			[Result.from_values("t", "msg", file="file", line=5),
499			Result.from_values("t", "msg", file="file", line=6)],
500			{abspath("file"): ["line " + str(i + 1) for i in range(5)]},
501			{},
502			color=False)
503			self.assertEqual("\n"
504			"file\n"
505			"\| 5\| line 5\n"
506			"\| \| [NORMAL] t:\n"
507			"\| \| msg\n"
508			"\n"
509			"file\n"
510			"\| \| {}\n"
511			"\| \| [NORMAL] t:\n"
512			"\| \| msg\n".format(STR_LINE_DOESNT_EXIST),
513			stdout.getvalue())
514
515			def test_print_results_without_line(self):
516			with retrieve_stdout() as stdout:
517			print_results(
518			self.log_printer,
519			Section(""),
520			[Result.from_values("t", "msg", file="file")],
521			{abspath("file"): []},
522			{},
523			color=False)
524			self.assertEqual(
525			"\nfile\n"
526			"\| \| [NORMAL] t:\n"
527			"\| \| msg\n",
528			stdout.getvalue())
529
530			def test_print_bears_empty(self):
531			with retrieve_stdout() as stdout:
532			bears = {}
533			print_bears(self.log_printer.printer, bears, True)
534			self.assertEqual("No bears to show.\n", stdout.getvalue())
535			with retrieve_stdout() as stdout:
536			bears = {}
537			print_bears(self.log_printer.printer, bears, False)
538			self.assertEqual("No bears to show.\n", stdout.getvalue())
539
540			def test_print_bears(self):
541			with retrieve_stdout() as stdout:
542			bears = {TestBear: ["default", "docs"]}
543			print_bears(self.log_printer.printer, bears, False)
544			expected_string = "TestBear:\n"
545			expected_string += " Test bear Description.\n\n"
546			expected_string += " Used in:\n"
547			expected_string += " * default\n"
548			expected_string += " * docs\n\n"
549			expected_string += " Needed Settings:\n"
550			expected_string += " * setting1: Required Setting.\n\n"
551			expected_string += " Optional Settings:\n"
552			expected_string += " * setting2: Optional Setting. ("
553			expected_string += "Optional, defaults to 'None'."
554			expected_string += ")\n\n"
555
556			self.assertEqual(expected_string, stdout.getvalue())
557
558			def test_print_bears_no_settings(self):
559			with retrieve_stdout() as stdout:
560			bears = {SomeBear: ["default"]}
561			print_bears(self.log_printer.printer, bears, False)
562			expected_string = "SomeBear:\n"
563			expected_string += " Some Description.\n\n"
564			expected_string += " Used in:\n"
565			expected_string += " * default\n\n"
566			expected_string += " No needed settings.\n\n"
567			expected_string += " No optional settings.\n\n"
568
569			self.assertEqual(expected_string, stdout.getvalue())
570
571			def test_print_bears_no_needed_settings(self):
572			with retrieve_stdout() as stdout:
573			bears = {SomeOtherBear: ["test"]}
574			print_bears(self.log_printer.printer, bears, False)
575			expected_string = "SomeOtherBear:\n"
576			expected_string += " This is a Bear.\n\n"
577			expected_string += " Used in:\n"
578			expected_string += " * test\n\n"
579			expected_string += " No needed settings.\n\n"
580			expected_string += " Optional Settings:\n"
581			expected_string += " * setting: This is an optional setting. ("
582			expected_string += "Optional, defaults to 'None'."
583			expected_string += ")\n\n"
584
585			self.assertEqual(expected_string, stdout.getvalue())
586
587			def test_print_bears_no_optional_settings(self):
588			with retrieve_stdout() as stdout:
589			bears = {TestBear2: ["test"]}
590			print_bears(self.log_printer.printer, bears, False)
591			expected_string = "TestBear2:\n"
592			expected_string += " Test bear 2 description.\n\n"
593			expected_string += " Used in:\n"
594			expected_string += " * test\n\n"
595			expected_string += " Needed Settings:\n"
596			expected_string += " * setting1: Required Setting.\n\n"
597			expected_string += " No optional settings.\n\n"
598
599			self.assertEqual(expected_string, stdout.getvalue())
600
601			def test_print_bears_no_sections(self):
602			with retrieve_stdout() as stdout:
603			bears = {SomeBear: []}
604			print_bears(self.log_printer.printer, bears, False)
605			expected_string = "SomeBear:\n"
606			expected_string += " Some Description.\n\n"
607			expected_string += " No sections.\n\n"
608			expected_string += " No needed settings.\n\n"
609			expected_string += " No optional settings.\n\n"
610
611			self.assertEqual(expected_string, stdout.getvalue())
612
613			def test_show_bears(self):
614			with retrieve_stdout() as stdout:
615			bears = {SomelocalBear: ['default', 'test'],
616			SomeglobalBear: ['default', 'test']}
617			print_bears(self.log_printer.printer, bears, False)
618			expected_string = stdout.getvalue()
619			self.maxDiff = None
620			with retrieve_stdout() as stdout:
621			show_bears(self.local_bears,
622			self.global_bears,
623			False,
624			self.log_printer.printer)
625			self.assertEqual(expected_string, stdout.getvalue())
626
627			with retrieve_stdout() as stdout:
628			show_bears(self.local_bears,
629			self.global_bears,
630			True,
631			self.log_printer.printer)
632			self.assertEqual(" * SomeglobalBear\n"
633			" * SomelocalBear\n", stdout.getvalue())
634
635
636			# Own test because this is easy and not tied to the rest
637			class PrintFormattedResultsTest(unittest.TestCase):
638
639			def setUp(self):
640			self.printer = StringPrinter()
641			self.logger = LogPrinter(self.printer)
642			self.section = Section("t")
643
644			def test_default_format(self):
645			expected_string = ("id:-?[0-9]+:origin:1:file:None:from_line:None:"
646			"from_column:None:to_line:None:to_column:None:"
647			"severity:1:msg:2\n")
648			with retrieve_stdout() as stdout:
649			print_results_formatted(self.logger,
650			self.section,
651			[Result("1", "2")],
652			None,
653			None)
654			self.assertRegex(stdout.getvalue(), expected_string)
655
656			def test_multiple_ranges(self):
657			expected_string = (
658			"id:-?[0-9]+:origin:1:.file:.another_file:from_line:5:"
659			"from_column:3:to_line:5:to_column:5:"
660			"severity:1:msg:2\n"
661			"id:-?[0-9]+:origin:1:.file:.some_file:from_line:5:"
662			"from_column:None:to_line:7:to_column:None:"
663			"severity:1:msg:2\n")
664			affected_code = (SourceRange.from_values("some_file", 5, end_line=7),
665			SourceRange.from_values("another_file", 5, 3, 5, 5))
666			with retrieve_stdout() as stdout:
667			print_results_formatted(self.logger,
668			self.section,
669			[Result("1", "2", affected_code)],
670			None,
671			None)
672			self.assertRegex(stdout.getvalue(), expected_string)
673
674			def test_bad_format(self):
675			self.section.append(Setting("format_str", "{nonexistant}"))
676			print_results_formatted(self.logger,
677			self.section,
678			[Result("1", "2")],
679			None,
680			None)
681			self.assertRegex(self.printer.string, ".Unable to print.")
682
683			def test_good_format(self):
684			self.section.append(Setting("format_str", "{origin}"))
685			with retrieve_stdout() as stdout:
686			print_results_formatted(self.logger,
687			self.section,
688			[Result("1", "2")],
689			None,
690			None)
691			self.assertEqual(stdout.getvalue(), "1\n")
692
693			def test_empty_list(self):
694			self.section.append(Setting("format_str", "{origin}"))
695			# Shouldn't attempt to format the string None and will fail badly if
696			# its done wrong.
697			print_results_formatted(None,
698			self.section,
699			[],
700			None,
701			None,
702			None)
703

coala-analyzer / coala

Pull Request — master (#1626)

coalib.tests.output.SomeBear A

Complexity

Size/Duplication

Duplication Side-by-Side

Filter issues like