TestBear.get_dependencies() - Code Metrics - Inspection of "Bear: get_dependencies() -> BEAR_DEPS" - coala-analyzer/coala - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#2592)

by Udayan

created 2016-08-08 09:29 UTC

TestBear.get_dependencies() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
dl	0
loc	3
rs	10
c	0
b	0
f	0

import multiprocessing
import unittest
from os.path import abspath

from coalib.bears.Bear import Bear
from coalib.results.Result import Result
from coalib.output.printers.LOG_LEVEL import LOG_LEVEL
from coalib.processes.communication.LogMessage import LogMessage
from coalib.settings.Section import Section
from coalib.settings.Setting import Setting


class TestBear(Bear):

    BEAR_DEPS = [BadTestBear]


    def __init__(self, section, queue):
        Bear.__init__(self, section, queue)

    def run(self):
        self.print("set", "up", delimiter="=")
        self.err("teardown")
        self.err()


class BadTestBear(Bear):


    def __init__(self, section, queue):
        Bear.__init__(self, section, queue)

    def run(self):
        raise NotImplementedError


class TypedTestBear(Bear):

    def __init__(self, section, queue):
        Bear.__init__(self, section, queue)
        self.was_executed = False

    def run(self, something: int):
        self.was_executed = True
        return []


class BearWithPrerequisites(Bear):
    prerequisites_fulfilled = True

    def __init__(self, section, queue, prerequisites_fulfilled):
        BearWithPrerequisites.prerequisites_fulfilled = prerequisites_fulfilled
        Bear.__init__(self, section, queue)
        self.was_executed = False

    def run(self):
        self.was_executed = True
        return []

    @classmethod
    def check_prerequisites(cls):
        return cls.prerequisites_fulfilled


class BearTest(unittest.TestCase):

    def setUp(self):
        self.queue = multiprocessing.Queue()
        self.settings = Section("test_settings")
        self.uut = TestBear(self.settings, self.queue)

    def test_simple_api(self):
        self.assertRaises(TypeError, TestBear, self.settings, 2)
        self.assertRaises(TypeError, TestBear, None, self.queue)
        self.assertRaises(NotImplementedError, self.uut.kind)

        base = Bear(self.settings, None)
        self.assertRaises(NotImplementedError, base.run)
        self.assertEqual(base.get_non_optional_settings(), {})

    def test_message_queue(self):
        self.uut.execute()
        self.check_message(LOG_LEVEL.DEBUG,
                           "Running bear TestBear...")
        self.check_message(LOG_LEVEL.DEBUG, "set=up")
        self.check_message(LOG_LEVEL.ERROR, "teardown")

    def test_bad_bear(self):
        self.uut = BadTestBear(self.settings, self.queue)
        self.uut.execute()
        self.check_message(LOG_LEVEL.DEBUG)
        self.check_message(LOG_LEVEL.WARNING,
                           "Bear BadTestBear failed to run. Take a look at "
                           "debug messages (`-L DEBUG`) for further "
                           "information.")
        # debug message contains custom content, dont test this here
        self.queue.get()

    def test_inconvertible(self):
        self.uut = TypedTestBear(self.settings, self.queue)
        self.settings.append(Setting("something", "5"))
        self.uut.execute()
        self.check_message(LOG_LEVEL.DEBUG)
        self.assertTrue(self.uut.was_executed)

        self.settings.append(Setting("something", "nonsense"))
        self.uut.was_executed = False
        self.uut.execute()
        self.check_message(LOG_LEVEL.DEBUG)
        self.check_message(LOG_LEVEL.WARNING)
        self.assertTrue(self.queue.empty())
        self.assertFalse(self.uut.was_executed)

    def check_message(self, log_level, message=None):
        msg = self.queue.get()
        self.assertIsInstance(msg, LogMessage)
        if message:
            self.assertEqual(msg.message, message)

        self.assertEqual(msg.log_level, log_level, msg)

    def test_no_queue(self):
        uut = TestBear(self.settings, None)
        uut.execute()  # No exceptions

    def test_dependencies(self):
        self.assertEqual(Bear.BEAR_DEPS, [])
        self.assertEqual(Bear.missing_dependencies([]), [])
        self.assertEqual(Bear.missing_dependencies([BadTestBear]), [])

        self.assertEqual(TestBear.missing_dependencies([]), [BadTestBear])
        self.assertEqual(TestBear.missing_dependencies([BadTestBear]), [])
        self.assertEqual(TestBear.missing_dependencies([TestBear]),
                         [BadTestBear])
        self.assertEqual(TestBear.missing_dependencies([TestBear,
                                                        BadTestBear]),
                         [])

    def test_check_prerequisites(self):
        uut = BearWithPrerequisites(self.settings, self.queue, True)
        uut.execute()
        self.check_message(LOG_LEVEL.DEBUG)
        self.assertTrue(self.queue.empty())
        self.assertTrue(uut.was_executed)

        self.assertRaisesRegex(RuntimeError,
                               "The bear BearWithPrerequisites does not "
                               "fulfill all requirements\\.",
                               BearWithPrerequisites,
                               self.settings,
                               self.queue,
                               False)

        self.check_message(LOG_LEVEL.WARNING,
                           "The bear BearWithPrerequisites does not fulfill "
                           "all requirements.")
        self.assertTrue(self.queue.empty())

        self.assertRaisesRegex(RuntimeError,
                               "The bear BearWithPrerequisites does not "
                               "fulfill all requirements\\. Just because "
                               "I want to\\.",
                               BearWithPrerequisites,
                               self.settings,
                               self.queue,
                               "Just because I want to.")

        self.check_message(LOG_LEVEL.WARNING,
                           "The bear BearWithPrerequisites does not fulfill "
                           "all requirements. Just because I want to.")
        self.assertTrue(self.queue.empty())

    def test_get_config_dir(self):
        section = Section("default")
        section.append(Setting("files", "**", "/path/to/dir/config"))
        uut = TestBear(section, None)
        self.assertEqual(uut.get_config_dir(), abspath("/path/to/dir"))

    def test_new_result(self):
        bear = Bear(self.settings, None)
        result = bear.new_result('test message', '/tmp/testy')
        expected = Result.from_values(bear, 'test message', '/tmp/testy')
        self.assertEqual(result, expected)


1			import multiprocessing
2			import unittest
3			from os.path import abspath
4
5			from coalib.bears.Bear import Bear
6			from coalib.results.Result import Result
7			from coalib.output.printers.LOG_LEVEL import LOG_LEVEL
8			from coalib.processes.communication.LogMessage import LogMessage
9			from coalib.settings.Section import Section
10			from coalib.settings.Setting import Setting
11
12
13			class TestBear(Bear):
14
15			BEAR_DEPS = [BadTestBear]
			0 ignored issues – show Bug introduced 2016-08-08 09:31 UTC by Report Bug Copy Issue Report The variable `BadTestBear` was used before it was assigned. Loading history...
16
17			def __init__(self, section, queue):
18			Bear.__init__(self, section, queue)
19
20			def run(self):
21			self.print("set", "up", delimiter="=")
22			self.err("teardown")
23			self.err()
24
25
26			class BadTestBear(Bear):
			0 ignored issues – show Unused Code introduced 2016-02-22 07:01 UTC by Report Bug Copy Issue Report This abstract class does not seem to be used anywhere. Loading history...
27
28			def __init__(self, section, queue):
29			Bear.__init__(self, section, queue)
30
31			def run(self):
32			raise NotImplementedError
33
34
35			class TypedTestBear(Bear):
36
37			def __init__(self, section, queue):
38			Bear.__init__(self, section, queue)
39			self.was_executed = False
40
41			def run(self, something: int):
42			self.was_executed = True
43			return []
44
45
46			class BearWithPrerequisites(Bear):
47			prerequisites_fulfilled = True
48
49			def __init__(self, section, queue, prerequisites_fulfilled):
50			BearWithPrerequisites.prerequisites_fulfilled = prerequisites_fulfilled
51			Bear.__init__(self, section, queue)
52			self.was_executed = False
53
54			def run(self):
55			self.was_executed = True
56			return []
57
58			@classmethod
59			def check_prerequisites(cls):
60			return cls.prerequisites_fulfilled
61
62
63			class BearTest(unittest.TestCase):
64
65			def setUp(self):
66			self.queue = multiprocessing.Queue()
67			self.settings = Section("test_settings")
68			self.uut = TestBear(self.settings, self.queue)
69
70			def test_simple_api(self):
71			self.assertRaises(TypeError, TestBear, self.settings, 2)
72			self.assertRaises(TypeError, TestBear, None, self.queue)
73			self.assertRaises(NotImplementedError, self.uut.kind)
74
75			base = Bear(self.settings, None)
76			self.assertRaises(NotImplementedError, base.run)
77			self.assertEqual(base.get_non_optional_settings(), {})
78
79			def test_message_queue(self):
80			self.uut.execute()
81			self.check_message(LOG_LEVEL.DEBUG,
82			"Running bear TestBear...")
83			self.check_message(LOG_LEVEL.DEBUG, "set=up")
84			self.check_message(LOG_LEVEL.ERROR, "teardown")
85
86			def test_bad_bear(self):
87			self.uut = BadTestBear(self.settings, self.queue)
88			self.uut.execute()
89			self.check_message(LOG_LEVEL.DEBUG)
90			self.check_message(LOG_LEVEL.WARNING,
91			"Bear BadTestBear failed to run. Take a look at "
92			"debug messages (`-L DEBUG`) for further "
93			"information.")
94			# debug message contains custom content, dont test this here
95			self.queue.get()
96
97			def test_inconvertible(self):
98			self.uut = TypedTestBear(self.settings, self.queue)
99			self.settings.append(Setting("something", "5"))
100			self.uut.execute()
101			self.check_message(LOG_LEVEL.DEBUG)
102			self.assertTrue(self.uut.was_executed)
103
104			self.settings.append(Setting("something", "nonsense"))
105			self.uut.was_executed = False
106			self.uut.execute()
107			self.check_message(LOG_LEVEL.DEBUG)
108			self.check_message(LOG_LEVEL.WARNING)
109			self.assertTrue(self.queue.empty())
110			self.assertFalse(self.uut.was_executed)
111
112			def check_message(self, log_level, message=None):
113			msg = self.queue.get()
114			self.assertIsInstance(msg, LogMessage)
115			if message:
116			self.assertEqual(msg.message, message)
117
118			self.assertEqual(msg.log_level, log_level, msg)
119
120			def test_no_queue(self):
121			uut = TestBear(self.settings, None)
122			uut.execute() # No exceptions
123
124			def test_dependencies(self):
125			self.assertEqual(Bear.BEAR_DEPS, [])
126			self.assertEqual(Bear.missing_dependencies([]), [])
127			self.assertEqual(Bear.missing_dependencies([BadTestBear]), [])
128
129			self.assertEqual(TestBear.missing_dependencies([]), [BadTestBear])
130			self.assertEqual(TestBear.missing_dependencies([BadTestBear]), [])
131			self.assertEqual(TestBear.missing_dependencies([TestBear]),
132			[BadTestBear])
133			self.assertEqual(TestBear.missing_dependencies([TestBear,
134			BadTestBear]),
135			[])
136
137			def test_check_prerequisites(self):
138			uut = BearWithPrerequisites(self.settings, self.queue, True)
139			uut.execute()
140			self.check_message(LOG_LEVEL.DEBUG)
141			self.assertTrue(self.queue.empty())
142			self.assertTrue(uut.was_executed)
143
144			self.assertRaisesRegex(RuntimeError,
145			"The bear BearWithPrerequisites does not "
146			"fulfill all requirements\\.",
147			BearWithPrerequisites,
148			self.settings,
149			self.queue,
150			False)
151
152			self.check_message(LOG_LEVEL.WARNING,
153			"The bear BearWithPrerequisites does not fulfill "
154			"all requirements.")
155			self.assertTrue(self.queue.empty())
156
157			self.assertRaisesRegex(RuntimeError,
158			"The bear BearWithPrerequisites does not "
159			"fulfill all requirements\\. Just because "
160			"I want to\\.",
161			BearWithPrerequisites,
162			self.settings,
163			self.queue,
164			"Just because I want to.")
165
166			self.check_message(LOG_LEVEL.WARNING,
167			"The bear BearWithPrerequisites does not fulfill "
168			"all requirements. Just because I want to.")
169			self.assertTrue(self.queue.empty())
170
171			def test_get_config_dir(self):
172			section = Section("default")
173			section.append(Setting("files", "**", "/path/to/dir/config"))
174			uut = TestBear(section, None)
175			self.assertEqual(uut.get_config_dir(), abspath("/path/to/dir"))
176
177			def test_new_result(self):
178			bear = Bear(self.settings, None)
179			result = bear.new_result('test message', '/tmp/testy')
180			expected = Result.from_values(bear, 'test message', '/tmp/testy')
181			self.assertEqual(result, expected)
182

coala-analyzer / coala

Pull Request — master (#2592)

TestBear.get_dependencies() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like