x/stacktach-winchester
Code Issues Proposed changes
stacktach-winchester/tests/test_debugger.py
Levi Blackstone 8892801205 Add PEP8 check and fix related issues 
- Add PEP8 section to tox.ini
- Add hacking to requirements to enforce OpenStack style requirements
- Fix large number of formatting issues flagged by flake8 check
- Add copyright notices to all remaining files
- Fix bug in trigger_manager related to logging calls
- Add .gitignore file

Change-Id: I755ab9c8bcc436836f9006fcd671408cc77214c4
2015-05-04 10:33:25 -05:00

239 lines
8.7 KiB
Python
Raw Blame History

# Copyright (c) 2014 Dark Secret Software Inc.
# Copyright (c) 2015 Rackspace
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
# implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import unittest2 as unittest
import mock
from winchester import debugging
class TestDebugManager(unittest.TestCase):
def setUp(self):
super(TestDebugManager, self).setUp()
self.debug_manager = debugging.DebugManager()
def test_get_debugger_none(self):
debugger = self.debug_manager.get_debugger(None)
self.assertEqual("n/a", debugger._name)
self.assertEqual(2, debugger._debug_level)
def test_get_debugger_off(self):
tdef = mock.MagicMock(name="tdef")
tdef.name = "my_trigger"
tdef.debug_level = 0
debugger = self.debug_manager.get_debugger(tdef)
self.assertTrue(isinstance(debugger, debugging.NoOpDebugger))
self.assertEqual(debugger,
self.debug_manager._debuggers['my_trigger'])
debugger2 = self.debug_manager.get_debugger(tdef)
self.assertEqual(debugger, debugger2)
def test_get_debugger_on(self):
tdef = mock.MagicMock(name="tdef")
tdef.name = "my_trigger"
tdef.debug_level = 1
debugger = self.debug_manager.get_debugger(tdef)
self.assertTrue(isinstance(debugger, debugging.DetailedDebugger))
self.assertEqual(debugger,
self.debug_manager._debuggers['my_trigger'])
debugger2 = self.debug_manager.get_debugger(tdef)
self.assertEqual(debugger, debugger2)
def test_dump_group_level1(self):
debugger = mock.MagicMock(name="debugger")
debugger.get_debug_level.return_value = 1
group = mock.MagicMock(name="group")
group._name = "my_group"
group._match = 1
group._mismatch = 2
debugger.get_group.return_value = group
with mock.patch.object(debugging, "logger") as log:
self.debug_manager.dump_group(debugger, "my_group")
log.info.assert_called_once_with(
"my_group Criteria: 3 checks, 1 passed")
def test_dump_group_level2(self):
debugger = mock.MagicMock(name="debugger")
debugger.get_debug_level.return_value = 2
group = mock.MagicMock(name="group")
group._name = "my_group"
group._match = 1
group._mismatch = 2
group._reasons = {"foo": 12}
debugger.get_group.return_value = group
with mock.patch.object(debugging, "logger") as log:
self.debug_manager.dump_group(debugger, "my_group")
self.assertEqual(log.info.call_args_list,
[mock.call(
"my_group Criteria: 3 checks, 1 passed"),
mock.call(" - foo = 12")])
def test_dump_counters(self):
debugger = mock.MagicMock(name="debugger")
debugger._counters = {'foo': 12}
with mock.patch.object(debugging, "logger") as log:
self.debug_manager.dump_counters(debugger)
log.info.assert_called_once_with('Counter "foo" = 12')
def test_dump_debuggers_off(self):
debugger = mock.MagicMock(name="debugger")
debugger.get_debug_level.return_value = 0
self.debug_manager._debuggers = {"foo": debugger}
with mock.patch.object(debugging, "logger") as log:
self.debug_manager.dump_debuggers()
self.assertEqual(0, log.info.call_count)
def test_dump_debuggers_on(self):
debugger = mock.MagicMock(name="debugger")
debugger.get_debug_level.return_value = 1
debugger._name = "my_debugger"
group = mock.MagicMock(name="group")
debugger._groups = {"my_group": group}
self.debug_manager._debuggers = {"foo": debugger}
with mock.patch.object(self.debug_manager, "dump_counters") as ctr:
with mock.patch.object(self.debug_manager, "dump_group") as grp:
with mock.patch.object(debugging, "logger") as log:
self.debug_manager.dump_debuggers()
self.assertEqual(
log.info.call_args_list,
[mock.call(
"---- Trigger Definition: my_debugger ----"),
mock.call(
"----------------------------")])
grp.assert_called_once_with(debugger, "my_group")
ctr.assert_called_once_with(debugger)
debugger.reset.assert_called_once_with()
class TestDetailedDebugger(unittest.TestCase):
def setUp(self):
super(TestDetailedDebugger, self).setUp()
self.debugger = debugging.DetailedDebugger("my_debugger", 2)
def test_constructor(self):
with mock.patch("winchester.debugging.DetailedDebugger.reset") \
as reset:
debugging.DetailedDebugger("my_debugger", 2)
reset.assert_called_once_with()
self.assertEqual(self.debugger._name, "my_debugger")
self.assertEqual(self.debugger._debug_level, 2)
def test_reset(self):
self.assertEqual(self.debugger._groups, {})
self.assertEqual(self.debugger._counters, {})
def test_get_group(self):
self.assertEqual(self.debugger._groups, {})
g = self.debugger.get_group("foo")
self.assertEqual(g._name, "foo")
self.assertTrue(self.debugger._groups['foo'])
def test_bump_counter(self):
self.assertEqual(self.debugger._counters, {})
self.debugger.bump_counter("foo")
self.assertEqual(self.debugger._counters['foo'], 1)
self.debugger.bump_counter("foo", 2)
self.assertEqual(self.debugger._counters['foo'], 3)
def test_get_debug_level(self):
self.assertEqual(self.debugger.get_debug_level(), 2)
class TestNoOpDebugger(unittest.TestCase):
def setUp(self):
super(TestNoOpDebugger, self).setUp()
self.debugger = debugging.NoOpDebugger("my_debugger", 2)
def test_reset(self):
self.debugger.reset()
def test_get_group(self):
g = self.debugger.get_group("foo")
self.assertEqual(g, self.debugger.noop_group)
def test_bump_counter(self):
self.debugger.bump_counter("foo")
self.debugger.bump_counter("foo", 2)
def test_get_debug_level(self):
self.assertEqual(self.debugger.get_debug_level(), 0)
class TestGroup(unittest.TestCase):
def setUp(self):
super(TestGroup, self).setUp()
self.group = debugging.Group("my_group")
def test_constructor(self):
self.assertEqual("my_group", self.group._name)
self.assertEqual(0, self.group._match)
self.assertEqual(0, self.group._mismatch)
self.assertEqual({}, self.group._reasons)
def test_match(self):
self.assertTrue(self.group.match())
self.assertEqual(1, self.group._match)
def test_mismatch(self):
self.assertFalse(self.group.mismatch("reason"))
self.assertEqual(1, self.group._mismatch)
self.assertEqual(1, self.group._reasons['reason'])
def test_check(self):
self.assertTrue(self.group.check(True, "reason"))
self.assertEqual(1, self.group._match)
self.assertEqual(0, self.group._mismatch)
self.assertEqual({}, self.group._reasons)
self.assertTrue(self.group.check(True, "reason"))
self.assertEqual(2, self.group._match)
self.assertEqual(0, self.group._mismatch)
self.assertEqual({}, self.group._reasons)
self.assertFalse(self.group.check(False, "reason"))
self.assertEqual(2, self.group._match)
self.assertEqual(1, self.group._mismatch)
self.assertEqual(1, self.group._reasons['reason'])
self.assertFalse(self.group.check(False, "reason"))
self.assertEqual(2, self.group._match)
self.assertEqual(2, self.group._mismatch)
self.assertEqual(2, self.group._reasons['reason'])
class TestNoOpGroup(unittest.TestCase):
def setUp(self):
super(TestNoOpGroup, self).setUp()
self.group = debugging.NoOpGroup()
def test_match(self):
self.assertTrue(self.group.match())
def test_mismatch(self):
self.assertFalse(self.group.mismatch("reason"))
def test_check(self):
self.assertTrue(self.group.check(True, "reason"))
self.assertFalse(self.group.check(False, "reason"))
View Git Blame Copy Permalink