[formatting] reformat using "black -t py34"
getting rid of thinking about consistent formatting...
This commit is contained in:
tobi-wan-kenobi
parent
fa98bcbdd1
commit
30c1f712a6
119 changed files with 3961 additions and 3495 deletions
|
|
@ -3,74 +3,83 @@ import unittest
|
|||
|
||||
import core.config
|
||||
|
||||
|
||||
class config(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.someModules = [ 'b', 'x', 'a' ]
|
||||
self.moreModules = [ 'this', 'module', 'here' ]
|
||||
self.someTheme = 'some-theme'
|
||||
self.someIconset = 'some-iconset'
|
||||
self.someModules = ["b", "x", "a"]
|
||||
self.moreModules = ["this", "module", "here"]
|
||||
self.someTheme = "some-theme"
|
||||
self.someIconset = "some-iconset"
|
||||
self.defaultConfig = core.config.Config([])
|
||||
|
||||
def test_module(self):
|
||||
cfg = core.config.Config([ '-m' ] + self.someModules)
|
||||
cfg = core.config.Config(["-m"] + self.someModules)
|
||||
self.assertEqual(self.someModules, cfg.modules())
|
||||
|
||||
def test_module_ordering_maintained(self):
|
||||
cfg = core.config.Config([ '-m' ] + self.someModules + [ '-m' ] + self.moreModules)
|
||||
cfg = core.config.Config(["-m"] + self.someModules + ["-m"] + self.moreModules)
|
||||
self.assertEqual(self.someModules + self.moreModules, cfg.modules())
|
||||
|
||||
def test_default_interval(self):
|
||||
self.assertEqual(1, self.defaultConfig.interval())
|
||||
|
||||
def test_interval(self):
|
||||
cfg = core.config.Config([ '-p', 'interval=4'])
|
||||
cfg = core.config.Config(["-p", "interval=4"])
|
||||
self.assertEqual(4, cfg.interval())
|
||||
|
||||
def test_float_interval(self):
|
||||
cfg = core.config.Config([ '-p', 'interval=0.5'])
|
||||
cfg = core.config.Config(["-p", "interval=0.5"])
|
||||
self.assertEqual(0.5, cfg.interval())
|
||||
|
||||
def test_default_theme(self):
|
||||
self.assertEqual('default', self.defaultConfig.theme())
|
||||
self.assertEqual("default", self.defaultConfig.theme())
|
||||
|
||||
def test_theme(self):
|
||||
cfg = core.config.Config(['-t', self.someTheme])
|
||||
cfg = core.config.Config(["-t", self.someTheme])
|
||||
self.assertEqual(self.someTheme, cfg.theme())
|
||||
|
||||
def test_default_iconset(self):
|
||||
self.assertEqual('auto', self.defaultConfig.iconset())
|
||||
self.assertEqual("auto", self.defaultConfig.iconset())
|
||||
|
||||
def test_iconset(self):
|
||||
cfg = core.config.Config(['-i', self.someIconset])
|
||||
cfg = core.config.Config(["-i", self.someIconset])
|
||||
self.assertEqual(self.someIconset, cfg.iconset())
|
||||
|
||||
def test_right_to_left(self):
|
||||
cfg = core.config.Config(['-r'])
|
||||
cfg = core.config.Config(["-r"])
|
||||
self.assertTrue(cfg.reverse())
|
||||
self.assertFalse(self.defaultConfig.reverse())
|
||||
|
||||
def test_logfile(self):
|
||||
cfg = core.config.Config(['-f', 'my-custom-logfile'])
|
||||
cfg = core.config.Config(["-f", "my-custom-logfile"])
|
||||
self.assertEquals(None, self.defaultConfig.logfile())
|
||||
self.assertEquals('my-custom-logfile', cfg.logfile())
|
||||
self.assertEquals("my-custom-logfile", cfg.logfile())
|
||||
|
||||
def test_all_modules(self):
|
||||
modules = core.config.all_modules()
|
||||
self.assertGreater(len(modules), 0)
|
||||
for module in modules:
|
||||
pyname = '{}.py'.format(module)
|
||||
base = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', '..', 'modules'))
|
||||
self.assertTrue(os.path.exists(os.path.join(base, 'contrib', pyname)) or os.path.exists(os.path.join(base, 'core', pyname)))
|
||||
pyname = "{}.py".format(module)
|
||||
base = os.path.abspath(
|
||||
os.path.join(
|
||||
os.path.dirname(os.path.realpath(__file__)), "..", "..", "modules"
|
||||
)
|
||||
)
|
||||
self.assertTrue(
|
||||
os.path.exists(os.path.join(base, "contrib", pyname))
|
||||
or os.path.exists(os.path.join(base, "core", pyname))
|
||||
)
|
||||
|
||||
def test_list_output(self):
|
||||
with unittest.mock.patch('core.config.sys') as sys:
|
||||
cfg = core.config.Config([ '-l', 'themes' ])
|
||||
cfg = core.config.Config([ '-l', 'modules' ])
|
||||
cfg = core.config.Config([ '-l', 'modules-markdown' ])
|
||||
with unittest.mock.patch("core.config.sys") as sys:
|
||||
cfg = core.config.Config(["-l", "themes"])
|
||||
cfg = core.config.Config(["-l", "modules"])
|
||||
cfg = core.config.Config(["-l", "modules-markdown"])
|
||||
# TODO: think of some plausibility testing here
|
||||
|
||||
def test_missing_parameter(self):
|
||||
cfg = core.config.Config([ '-p', 'test.key' ])
|
||||
self.assertEqual('no-value-set', cfg.get('test.key', 'no-value-set'))
|
||||
cfg = core.config.Config(["-p", "test.key"])
|
||||
self.assertEqual("no-value-set", cfg.get("test.key", "no-value-set"))
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
|
|
@ -5,59 +5,62 @@ import core.widget
|
|||
import core.module
|
||||
import core.config
|
||||
|
||||
|
||||
class TestModule(core.module.Module):
|
||||
def __init__(self, config=None, theme=None):
|
||||
config = core.config.Config([])
|
||||
super().__init__(config, theme, core.widget.Widget(self.get))
|
||||
self.text = ''
|
||||
self.text = ""
|
||||
|
||||
@core.decorators.scrollable
|
||||
def get(self, widget):
|
||||
return self.text
|
||||
|
||||
|
||||
class config(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.module = TestModule()
|
||||
self.widget = self.module.widget()
|
||||
self.width = 10
|
||||
self.module.set('width', self.width)
|
||||
self.module.set("width", self.width)
|
||||
|
||||
def test_no_text(self):
|
||||
self.assertEqual('', self.module.text)
|
||||
self.assertEqual('', self.module.get(self.widget))
|
||||
self.assertEqual("", self.module.text)
|
||||
self.assertEqual("", self.module.get(self.widget))
|
||||
|
||||
def test_smaller(self):
|
||||
self.module.text = 'test'
|
||||
self.module.text = "test"
|
||||
self.assertLess(len(self.module.text), self.width)
|
||||
self.assertEqual('test', self.module.get(self.widget))
|
||||
self.assertEqual("test", self.module.get(self.widget))
|
||||
|
||||
def test_bigger(self):
|
||||
self.module.text = 'abcdefghijklmnopqrst'
|
||||
self.module.text = "abcdefghijklmnopqrst"
|
||||
self.assertGreater(len(self.module.text), self.width)
|
||||
self.assertEqual(self.module.text[:self.width], self.module.get(self.widget))
|
||||
self.assertEqual(self.module.text[: self.width], self.module.get(self.widget))
|
||||
|
||||
def test_bounce(self):
|
||||
self.module.text = 'abcd'
|
||||
self.module.set('width', 2)
|
||||
self.assertEqual('ab', self.module.get(self.widget))
|
||||
self.assertEqual('bc', self.module.get(self.widget))
|
||||
self.assertEqual('cd', self.module.get(self.widget))
|
||||
self.assertEqual('bc', self.module.get(self.widget))
|
||||
self.assertEqual('ab', self.module.get(self.widget))
|
||||
self.assertEqual('bc', self.module.get(self.widget))
|
||||
self.assertEqual('cd', self.module.get(self.widget))
|
||||
self.assertEqual('bc', self.module.get(self.widget))
|
||||
self.assertEqual('ab', self.module.get(self.widget))
|
||||
self.module.text = "abcd"
|
||||
self.module.set("width", 2)
|
||||
self.assertEqual("ab", self.module.get(self.widget))
|
||||
self.assertEqual("bc", self.module.get(self.widget))
|
||||
self.assertEqual("cd", self.module.get(self.widget))
|
||||
self.assertEqual("bc", self.module.get(self.widget))
|
||||
self.assertEqual("ab", self.module.get(self.widget))
|
||||
self.assertEqual("bc", self.module.get(self.widget))
|
||||
self.assertEqual("cd", self.module.get(self.widget))
|
||||
self.assertEqual("bc", self.module.get(self.widget))
|
||||
self.assertEqual("ab", self.module.get(self.widget))
|
||||
|
||||
def test_nobounce(self):
|
||||
self.module.set('scrolling.bounce', False)
|
||||
self.module.text = 'abcd'
|
||||
self.module.set('width', 2)
|
||||
self.assertEqual('ab', self.module.get(self.widget))
|
||||
self.assertEqual('bc', self.module.get(self.widget))
|
||||
self.assertEqual('cd', self.module.get(self.widget))
|
||||
self.assertEqual('ab', self.module.get(self.widget))
|
||||
self.assertEqual('bc', self.module.get(self.widget))
|
||||
self.assertEqual('cd', self.module.get(self.widget))
|
||||
self.module.set("scrolling.bounce", False)
|
||||
self.module.text = "abcd"
|
||||
self.module.set("width", 2)
|
||||
self.assertEqual("ab", self.module.get(self.widget))
|
||||
self.assertEqual("bc", self.module.get(self.widget))
|
||||
self.assertEqual("cd", self.module.get(self.widget))
|
||||
self.assertEqual("ab", self.module.get(self.widget))
|
||||
self.assertEqual("bc", self.module.get(self.widget))
|
||||
self.assertEqual("cd", self.module.get(self.widget))
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
|
|
@ -2,25 +2,26 @@ import unittest
|
|||
|
||||
import core.event
|
||||
|
||||
|
||||
class event(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.someEvent = 'event'
|
||||
self.someEvent = "event"
|
||||
self.called = {}
|
||||
self.params = []
|
||||
core.event.clear()
|
||||
|
||||
def callback1(self):
|
||||
self.called['callback1'] = True
|
||||
self.called["callback1"] = True
|
||||
|
||||
def callback2(self):
|
||||
self.called['callback2'] = True
|
||||
self.called["callback2"] = True
|
||||
|
||||
def callback_args(self, val1, val2):
|
||||
self.called['callback_args'] = True
|
||||
self.called["callback_args"] = True
|
||||
self.params = [val1, val2]
|
||||
|
||||
def callback_kwargs(self, val1, val2, key1=None, key2=None):
|
||||
self.called['callback_kwargs'] = True
|
||||
self.called["callback_kwargs"] = True
|
||||
self.params = [val1, val2, key1, key2]
|
||||
|
||||
def test_simple_callback(self):
|
||||
|
|
@ -32,27 +33,30 @@ class event(unittest.TestCase):
|
|||
self.assertEqual(2, len(self.called.keys()))
|
||||
|
||||
def test_arg_callback(self):
|
||||
core.event.register(self.someEvent, self.callback_args, 'a', 'b')
|
||||
core.event.register(self.someEvent, self.callback_args, "a", "b")
|
||||
core.event.trigger(self.someEvent)
|
||||
self.assertEqual(1, len(self.called.keys()))
|
||||
self.assertEqual(['a', 'b'], self.params)
|
||||
self.assertEqual(["a", "b"], self.params)
|
||||
|
||||
def test_kwargs_callback(self):
|
||||
core.event.register(self.someEvent, self.callback_kwargs, 'a', 'b', key1='test', key2='x')
|
||||
core.event.register(
|
||||
self.someEvent, self.callback_kwargs, "a", "b", key1="test", key2="x"
|
||||
)
|
||||
core.event.trigger(self.someEvent)
|
||||
self.assertEqual(1, len(self.called.keys()))
|
||||
self.assertEqual(['a', 'b', 'test', 'x'], self.params)
|
||||
self.assertEqual(["a", "b", "test", "x"], self.params)
|
||||
|
||||
def test_arg_trigger(self):
|
||||
core.event.register(self.someEvent, self.callback_args)
|
||||
core.event.trigger(self.someEvent, 'a', 'b')
|
||||
core.event.trigger(self.someEvent, "a", "b")
|
||||
self.assertEqual(1, len(self.called.keys()))
|
||||
self.assertEqual(['a', 'b'], self.params)
|
||||
self.assertEqual(["a", "b"], self.params)
|
||||
|
||||
def test_kwargs_trigger(self):
|
||||
core.event.register(self.someEvent, self.callback_kwargs)
|
||||
core.event.trigger(self.someEvent, 'a', 'b', key1='test', key2='x')
|
||||
core.event.trigger(self.someEvent, "a", "b", key1="test", key2="x")
|
||||
self.assertEqual(1, len(self.called.keys()))
|
||||
self.assertEqual(['a', 'b', 'test', 'x'], self.params)
|
||||
self.assertEqual(["a", "b", "test", "x"], self.params)
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
|
|
@ -2,31 +2,44 @@ import unittest
|
|||
|
||||
import core.input
|
||||
|
||||
|
||||
class config(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.inputObject = core.input.Object()
|
||||
self.anotherObject = core.input.Object()
|
||||
self.someEvent = { 'button': core.input.LEFT_MOUSE, 'instance': self.inputObject.id }
|
||||
self.anotherEvent = { 'button': core.input.RIGHT_MOUSE, 'instance': self.inputObject.id}
|
||||
self.someEvent = {
|
||||
"button": core.input.LEFT_MOUSE,
|
||||
"instance": self.inputObject.id,
|
||||
}
|
||||
self.anotherEvent = {
|
||||
"button": core.input.RIGHT_MOUSE,
|
||||
"instance": self.inputObject.id,
|
||||
}
|
||||
self.callback = unittest.mock.MagicMock()
|
||||
self.callback2 = unittest.mock.MagicMock()
|
||||
self.someCommand = 'some sample command'
|
||||
self.someCommand = "some sample command"
|
||||
|
||||
def test_callable_gets_called(self):
|
||||
core.input.register(self.inputObject, self.someEvent['button'], self.callback)
|
||||
core.input.register(self.inputObject, self.someEvent["button"], self.callback)
|
||||
core.input.trigger(self.someEvent)
|
||||
self.callback.assert_called_once_with(self.someEvent)
|
||||
|
||||
def test_nonexistent_callback(self):
|
||||
core.input.register(self.inputObject, self.someEvent['button'], self.callback)
|
||||
core.input.register(self.inputObject, self.someEvent["button"], self.callback)
|
||||
core.input.trigger(self.anotherEvent)
|
||||
self.callback.assert_not_called()
|
||||
|
||||
def test_different_events(self):
|
||||
core.input.register(self.inputObject, self.someEvent['button'], self.callback)
|
||||
core.input.register(self.inputObject, self.anotherEvent['button'], self.callback)
|
||||
core.input.register(self.anotherObject, self.someEvent['button'], self.callback2)
|
||||
core.input.register(self.anotherObject, self.anotherEvent['button'], self.callback2)
|
||||
core.input.register(self.inputObject, self.someEvent["button"], self.callback)
|
||||
core.input.register(
|
||||
self.inputObject, self.anotherEvent["button"], self.callback
|
||||
)
|
||||
core.input.register(
|
||||
self.anotherObject, self.someEvent["button"], self.callback2
|
||||
)
|
||||
core.input.register(
|
||||
self.anotherObject, self.anotherEvent["button"], self.callback2
|
||||
)
|
||||
core.input.trigger(self.someEvent)
|
||||
core.input.trigger(self.anotherEvent)
|
||||
self.callback.assert_any_call(self.someEvent)
|
||||
|
|
@ -34,35 +47,42 @@ class config(unittest.TestCase):
|
|||
self.callback2.assert_not_called()
|
||||
|
||||
def test_multiple_registrations(self):
|
||||
core.input.register(self.inputObject, self.someEvent['button'], self.callback)
|
||||
core.input.register(self.inputObject, self.someEvent['button'], self.callback2)
|
||||
core.input.register(self.inputObject, self.someEvent["button"], self.callback)
|
||||
core.input.register(self.inputObject, self.someEvent["button"], self.callback2)
|
||||
core.input.trigger(self.someEvent)
|
||||
self.callback.assert_called_once_with(self.someEvent)
|
||||
self.callback2.assert_called_once_with(self.someEvent)
|
||||
|
||||
def test_event_names(self):
|
||||
self.assertEqual(core.input.button_name(core.input.LEFT_MOUSE), 'left-mouse')
|
||||
self.assertEqual(core.input.button_name(core.input.RIGHT_MOUSE), 'right-mouse')
|
||||
self.assertEqual(core.input.button_name(core.input.MIDDLE_MOUSE), 'middle-mouse')
|
||||
self.assertEqual(core.input.button_name(core.input.WHEEL_UP), 'wheel-up')
|
||||
self.assertEqual(core.input.button_name(core.input.WHEEL_DOWN), 'wheel-down')
|
||||
self.assertEqual(core.input.button_name(12345), 'n/a')
|
||||
self.assertEqual(core.input.button_name(core.input.LEFT_MOUSE), "left-mouse")
|
||||
self.assertEqual(core.input.button_name(core.input.RIGHT_MOUSE), "right-mouse")
|
||||
self.assertEqual(
|
||||
core.input.button_name(core.input.MIDDLE_MOUSE), "middle-mouse"
|
||||
)
|
||||
self.assertEqual(core.input.button_name(core.input.WHEEL_UP), "wheel-up")
|
||||
self.assertEqual(core.input.button_name(core.input.WHEEL_DOWN), "wheel-down")
|
||||
self.assertEqual(core.input.button_name(12345), "n/a")
|
||||
|
||||
def test_non_callable_callback(self):
|
||||
with unittest.mock.patch('core.input.util.cli') as cli:
|
||||
cli.execute.return_value = ''
|
||||
core.input.register(self.inputObject, self.someEvent['button'], self.someCommand)
|
||||
with unittest.mock.patch("core.input.util.cli") as cli:
|
||||
cli.execute.return_value = ""
|
||||
core.input.register(
|
||||
self.inputObject, self.someEvent["button"], self.someCommand
|
||||
)
|
||||
core.input.trigger(self.someEvent)
|
||||
cli.execute.assert_called_once_with(self.someCommand, wait=False)
|
||||
|
||||
def test_non_existent_callback(self):
|
||||
with unittest.mock.patch('core.input.util.cli') as cli:
|
||||
cli.execute.return_value = ''
|
||||
cli.execute.side_effect = RuntimeError('some-error')
|
||||
core.input.register(self.inputObject, self.someEvent['button'], self.someCommand)
|
||||
with unittest.mock.patch("core.input.util.cli") as cli:
|
||||
cli.execute.return_value = ""
|
||||
cli.execute.side_effect = RuntimeError("some-error")
|
||||
core.input.register(
|
||||
self.inputObject, self.someEvent["button"], self.someCommand
|
||||
)
|
||||
try:
|
||||
core.input.trigger(self.someEvent)
|
||||
except Exception:
|
||||
self.fail('input module propagated exception')
|
||||
self.fail("input module propagated exception")
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
|
|
@ -7,91 +7,116 @@ import core.module
|
|||
import core.widget
|
||||
import core.config
|
||||
|
||||
|
||||
class TestModule(core.module.Module):
|
||||
def update(self):
|
||||
if self.fail:
|
||||
raise Exception(self.error)
|
||||
pass
|
||||
|
||||
|
||||
class module(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.invalidModuleName = 'invalid-module-name'
|
||||
self.validModuleName = 'test'
|
||||
self.someWidget = core.widget.Widget('randomeWidgetContent', name='A')
|
||||
self.anotherWidget = core.widget.Widget('more Widget content', name='B')
|
||||
self.unusedWidgetName = 'C'
|
||||
self.invalidModuleName = "invalid-module-name"
|
||||
self.validModuleName = "test"
|
||||
self.someWidget = core.widget.Widget("randomeWidgetContent", name="A")
|
||||
self.anotherWidget = core.widget.Widget("more Widget content", name="B")
|
||||
self.unusedWidgetName = "C"
|
||||
|
||||
def test_loadinvalid_module(self):
|
||||
config = unittest.mock.MagicMock()
|
||||
module = core.module.load(module_name=self.invalidModuleName, config=config)
|
||||
self.assertEqual('core.module', module.__class__.__module__, 'module must be a module object')
|
||||
self.assertEqual('Error', module.__class__.__name__, 'an invalid module must be a core.module.Error')
|
||||
self.assertEqual(
|
||||
"core.module", module.__class__.__module__, "module must be a module object"
|
||||
)
|
||||
self.assertEqual(
|
||||
"Error",
|
||||
module.__class__.__name__,
|
||||
"an invalid module must be a core.module.Error",
|
||||
)
|
||||
|
||||
@unittest.skipIf(sys.version_info.major == 3 and sys.version_info.minor in [ 4, 5 ], 'importlib error reporting in Python 3.{4,5} different')
|
||||
@unittest.skipIf(
|
||||
sys.version_info.major == 3 and sys.version_info.minor in [4, 5],
|
||||
"importlib error reporting in Python 3.{4,5} different",
|
||||
)
|
||||
def test_importerror(self):
|
||||
with unittest.mock.patch('core.module.importlib') as importlib:
|
||||
importlib.import_module.side_effect = ImportError('some-error')
|
||||
with unittest.mock.patch("core.module.importlib") as importlib:
|
||||
importlib.import_module.side_effect = ImportError("some-error")
|
||||
|
||||
config = unittest.mock.MagicMock()
|
||||
module = core.module.load(module_name=self.validModuleName, config=config)
|
||||
module.widget().full_text()
|
||||
self.assertEqual('Error', module.__class__.__name__, 'an invalid module must be a core.module.Error')
|
||||
self.assertEqual(module.widget().full_text(), 'test: some-error')
|
||||
self.assertEqual(
|
||||
"Error",
|
||||
module.__class__.__name__,
|
||||
"an invalid module must be a core.module.Error",
|
||||
)
|
||||
self.assertEqual(module.widget().full_text(), "test: some-error")
|
||||
|
||||
def test_loadvalid_module(self):
|
||||
module = core.module.load(module_name=self.validModuleName)
|
||||
self.assertEqual('modules.core.{}'.format(self.validModuleName), module.__class__.__module__, 'module must be a modules.core.<name> object')
|
||||
self.assertEqual('Module', module.__class__.__name__, 'a valid module must have a Module class')
|
||||
self.assertEqual([], module.state(None), 'default state of module is empty')
|
||||
self.assertEqual(
|
||||
"modules.core.{}".format(self.validModuleName),
|
||||
module.__class__.__module__,
|
||||
"module must be a modules.core.<name> object",
|
||||
)
|
||||
self.assertEqual(
|
||||
"Module",
|
||||
module.__class__.__name__,
|
||||
"a valid module must have a Module class",
|
||||
)
|
||||
self.assertEqual([], module.state(None), "default state of module is empty")
|
||||
|
||||
def test_empty_widgets(self):
|
||||
module = core.module.Module(widgets=[])
|
||||
self.assertEqual([], module.widgets())
|
||||
|
||||
def test_error_widget(self):
|
||||
cfg = core.config.Config(shlex.split('-p test_module.foo=5'))
|
||||
module = core.module.Error(cfg, 'test-mod', 'xyz')
|
||||
self.assertEqual(['critical'], module.state(None), 'error module must have critical state')
|
||||
cfg = core.config.Config(shlex.split("-p test_module.foo=5"))
|
||||
module = core.module.Error(cfg, "test-mod", "xyz")
|
||||
self.assertEqual(
|
||||
["critical"], module.state(None), "error module must have critical state"
|
||||
)
|
||||
full_text = module.full_text(module.widget())
|
||||
self.assertTrue('test-mod' in full_text)
|
||||
self.assertTrue('xyz' in full_text)
|
||||
self.assertTrue("test-mod" in full_text)
|
||||
self.assertTrue("xyz" in full_text)
|
||||
|
||||
def test_single_widget(self):
|
||||
module = core.module.Module(widgets=self.someWidget)
|
||||
self.assertEqual([self.someWidget], module.widgets())
|
||||
|
||||
def test_widget_list(self):
|
||||
module = core.module.Module(widgets=[ self.someWidget, self.anotherWidget ])
|
||||
self.assertEqual([ self.someWidget, self.anotherWidget ], module.widgets())
|
||||
module = core.module.Module(widgets=[self.someWidget, self.anotherWidget])
|
||||
self.assertEqual([self.someWidget, self.anotherWidget], module.widgets())
|
||||
|
||||
def test_module_Name(self):
|
||||
module = TestModule()
|
||||
self.assertEqual('test_module', module.name, 'module has wrong name')
|
||||
self.assertEqual('test_module', module.module_name, 'module has wrong name')
|
||||
self.assertEqual("test_module", module.name, "module has wrong name")
|
||||
self.assertEqual("test_module", module.module_name, "module has wrong name")
|
||||
|
||||
def testvalid_parameter(self):
|
||||
cfg = core.config.Config(shlex.split('-p test_module.foo=5'))
|
||||
cfg = core.config.Config(shlex.split("-p test_module.foo=5"))
|
||||
module = TestModule(config=cfg)
|
||||
self.assertEqual(5, int(module.parameter('foo')))
|
||||
self.assertEqual(5, int(module.parameter("foo")))
|
||||
|
||||
def test_default_parameter(self):
|
||||
cfg = core.config.Config([])
|
||||
module = TestModule(config=cfg)
|
||||
self.assertEqual('default', module.parameter('foo', 'default'))
|
||||
self.assertEqual("default", module.parameter("foo", "default"))
|
||||
|
||||
def test_default_is_none(self):
|
||||
cfg = core.config.Config([])
|
||||
module = TestModule(config=cfg)
|
||||
self.assertEqual(None, module.parameter('foo'))
|
||||
self.assertEqual(None, module.parameter("foo"))
|
||||
|
||||
def test_error_widget(self):
|
||||
cfg = core.config.Config([])
|
||||
module = TestModule(config=cfg)
|
||||
module.fail = True
|
||||
module.error = '!!'
|
||||
module.error = "!!"
|
||||
module.update_wrapper()
|
||||
self.assertEqual(1, len(module.widgets()))
|
||||
self.assertEqual('error: !!', module.widget().full_text())
|
||||
self.assertEqual("error: !!", module.widget().full_text())
|
||||
|
||||
def test_get_widget_by_name(self):
|
||||
cfg = core.config.Config([])
|
||||
|
|
@ -106,10 +131,11 @@ class module(unittest.TestCase):
|
|||
cfg = core.config.Config([])
|
||||
module = TestModule(config=cfg, widgets=[self.someWidget, self.anotherWidget])
|
||||
|
||||
self.assertEqual('critical', module.threshold_state(100, 80, 99))
|
||||
self.assertEqual('warning', module.threshold_state(100, 80, 100))
|
||||
self.assertEqual('warning', module.threshold_state(81, 80, 100))
|
||||
self.assertEqual("critical", module.threshold_state(100, 80, 99))
|
||||
self.assertEqual("warning", module.threshold_state(100, 80, 100))
|
||||
self.assertEqual("warning", module.threshold_state(81, 80, 100))
|
||||
self.assertEqual(None, module.threshold_state(80, 80, 100))
|
||||
self.assertEqual(None, module.threshold_state(10, 80, 100))
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
|
|
@ -5,76 +5,93 @@ import core.config
|
|||
import core.output
|
||||
import core.module
|
||||
|
||||
|
||||
class TestModule(core.module.Module):
|
||||
pass
|
||||
|
||||
|
||||
class i3(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.i3 = core.output.i3()
|
||||
widget = unittest.mock.MagicMock()
|
||||
widget.full_text.return_value = "test"
|
||||
self.someModule = TestModule(config=core.config.Config([]),
|
||||
widgets=[widget, widget, widget])
|
||||
self.paddedTheme = core.theme.Theme(raw_data = {
|
||||
'defaults': { 'padding': ' ' }
|
||||
})
|
||||
self.separator = '***';
|
||||
self.separatorTheme = core.theme.Theme(raw_data = {
|
||||
'defaults': { 'separator': self.separator, 'fg': 'red', 'bg': 'blue' }
|
||||
})
|
||||
self.someModule = TestModule(
|
||||
config=core.config.Config([]), widgets=[widget, widget, widget]
|
||||
)
|
||||
self.paddedTheme = core.theme.Theme(raw_data={"defaults": {"padding": " "}})
|
||||
self.separator = "***"
|
||||
self.separatorTheme = core.theme.Theme(
|
||||
raw_data={
|
||||
"defaults": {"separator": self.separator, "fg": "red", "bg": "blue"}
|
||||
}
|
||||
)
|
||||
self.someBlock = core.output.block(
|
||||
theme=self.separatorTheme,
|
||||
module=self.someModule,
|
||||
widget=self.someModule.widget()
|
||||
module=self.someModule,
|
||||
widget=self.someModule.widget(),
|
||||
)
|
||||
|
||||
def test_start(self):
|
||||
core.event.clear()
|
||||
|
||||
all_data = self.i3.start()
|
||||
data = all_data['blocks']
|
||||
self.assertEqual(1, data['version'], 'i3bar protocol version 1 expected')
|
||||
self.assertTrue(data['click_events'], 'click events should be enabled')
|
||||
self.assertEqual('\n[', all_data['suffix'])
|
||||
data = all_data["blocks"]
|
||||
self.assertEqual(1, data["version"], "i3bar protocol version 1 expected")
|
||||
self.assertTrue(data["click_events"], "click events should be enabled")
|
||||
self.assertEqual("\n[", all_data["suffix"])
|
||||
|
||||
def test_stop(self):
|
||||
self.assertEqual('\n]', self.i3.stop()['suffix'], 'wrong i3bar protocol during stop')
|
||||
self.assertEqual(
|
||||
"\n]", self.i3.stop()["suffix"], "wrong i3bar protocol during stop"
|
||||
)
|
||||
|
||||
def test_no_modules_by_default(self):
|
||||
self.assertEqual(0, len(self.i3.modules()), 'module list should be empty by default')
|
||||
self.assertEqual(
|
||||
0, len(self.i3.modules()), "module list should be empty by default"
|
||||
)
|
||||
|
||||
def test_register_single_module(self):
|
||||
self.i3.modules(self.someModule)
|
||||
self.assertEqual(1, len(self.i3.modules()), 'setting single module does not work')
|
||||
self.assertEqual(
|
||||
1, len(self.i3.modules()), "setting single module does not work"
|
||||
)
|
||||
|
||||
def test_register_multiple_modules(self):
|
||||
self.i3.modules([ self.someModule, self.someModule, self.someModule ])
|
||||
self.assertEqual(3, len(self.i3.modules()), 'setting module list does not work')
|
||||
self.i3.modules([self.someModule, self.someModule, self.someModule])
|
||||
self.assertEqual(3, len(self.i3.modules()), "setting module list does not work")
|
||||
|
||||
def test_draw_existing_module(self):
|
||||
self.i3.test_draw = unittest.mock.MagicMock(return_value={
|
||||
'blocks': { 'test': True }, 'suffix': 'end'
|
||||
})
|
||||
self.i3.draw('test_draw')
|
||||
self.i3.test_draw = unittest.mock.MagicMock(
|
||||
return_value={"blocks": {"test": True}, "suffix": "end"}
|
||||
)
|
||||
self.i3.draw("test_draw")
|
||||
self.i3.test_draw.assert_called_once_with()
|
||||
|
||||
def test_empty_status_line(self):
|
||||
data = self.i3.statusline()
|
||||
self.assertEqual([], data['blocks'], 'expected empty list of status line entries')
|
||||
self.assertEqual(',', data['suffix'], 'expected "," as suffix')
|
||||
self.assertEqual(
|
||||
[], data["blocks"], "expected empty list of status line entries"
|
||||
)
|
||||
self.assertEqual(",", data["suffix"], 'expected "," as suffix')
|
||||
|
||||
def test_statusline(self):
|
||||
self.i3.modules([ self.someModule, self.someModule, self.someModule ])
|
||||
self.i3.modules([self.someModule, self.someModule, self.someModule])
|
||||
self.i3.update()
|
||||
data = self.i3.statusline()
|
||||
self.assertEqual(len(self.someModule.widgets())*3, len(data['blocks']), 'wrong number of widgets')
|
||||
self.assertEqual(
|
||||
len(self.someModule.widgets()) * 3,
|
||||
len(data["blocks"]),
|
||||
"wrong number of widgets",
|
||||
)
|
||||
|
||||
def test_padding(self):
|
||||
self.i3.theme(self.paddedTheme)
|
||||
blk = core.output.block(self.i3.theme(), self.someModule, self.someModule.widget())
|
||||
blk.set('full_text', 'abc')
|
||||
result = blk.dict()['full_text']
|
||||
self.assertEqual(' abc ', result)
|
||||
blk = core.output.block(
|
||||
self.i3.theme(), self.someModule, self.someModule.widget()
|
||||
)
|
||||
blk.set("full_text", "abc")
|
||||
result = blk.dict()["full_text"]
|
||||
self.assertEqual(" abc ", result)
|
||||
|
||||
def test_no_separator(self):
|
||||
result = self.i3.__separator_block(self.someModule, self.someModule.widget())
|
||||
|
|
@ -84,9 +101,12 @@ class i3(unittest.TestCase):
|
|||
self.i3.theme(self.separatorTheme)
|
||||
result = self.i3.__separator_block(self.someModule, self.someModule.widget())
|
||||
self.assertEqual(1, len(result))
|
||||
self.assertEqual('***', result[0].dict()['full_text'])
|
||||
self.assertTrue(result[0].dict().get('_decorator', False))
|
||||
self.assertEqual(self.separatorTheme.get('bg', self.someModule.widget()), result[0].dict()['color'])
|
||||
self.assertEqual("***", result[0].dict()["full_text"])
|
||||
self.assertTrue(result[0].dict().get("_decorator", False))
|
||||
self.assertEqual(
|
||||
self.separatorTheme.get("bg", self.someModule.widget()),
|
||||
result[0].dict()["color"],
|
||||
)
|
||||
|
||||
def test_dump_json(self):
|
||||
obj = unittest.mock.MagicMock()
|
||||
|
|
@ -95,47 +115,48 @@ class i3(unittest.TestCase):
|
|||
obj.dict_assert_called_once_with()
|
||||
|
||||
def test_assign(self):
|
||||
src = {
|
||||
'a': 'x', 'b': 'y', 'c': 'z'
|
||||
}
|
||||
src = {"a": "x", "b": "y", "c": "z"}
|
||||
dst = {}
|
||||
|
||||
core.output.assign(src, dst, 'a')
|
||||
self.assertEqual(dst['a'], src['a'])
|
||||
core.output.assign(src, dst, "a")
|
||||
self.assertEqual(dst["a"], src["a"])
|
||||
|
||||
core.output.assign(src, dst, '123', 'b')
|
||||
self.assertEqual(dst['123'], src['b'])
|
||||
core.output.assign(src, dst, "123", "b")
|
||||
self.assertEqual(dst["123"], src["b"])
|
||||
|
||||
core.output.assign(src, dst, 'blub', default='def')
|
||||
self.assertEqual('def', dst['blub'])
|
||||
core.output.assign(src, dst, "blub", default="def")
|
||||
self.assertEqual("def", dst["blub"])
|
||||
|
||||
def test_pango_detection(self):
|
||||
self.assertFalse(self.someBlock.is_pango({}))
|
||||
self.assertTrue(self.someBlock.is_pango({ 'pango': {} }))
|
||||
self.assertTrue(self.someBlock.is_pango({"pango": {}}))
|
||||
|
||||
def test_pangoize(self):
|
||||
self.assertEqual('test', self.someBlock.pangoize('test'))
|
||||
self.assertFalse('markup' in self.someBlock.dict())
|
||||
self.assertEqual("test", self.someBlock.pangoize("test"))
|
||||
self.assertFalse("markup" in self.someBlock.dict())
|
||||
|
||||
pango = self.someBlock.pangoize({ 'pango': { 'attr': 'blub', 'x': 'y', 'full_text': 'test' } })
|
||||
pango = self.someBlock.pangoize(
|
||||
{"pango": {"attr": "blub", "x": "y", "full_text": "test"}}
|
||||
)
|
||||
self.assertTrue('attr="blub"' in pango)
|
||||
self.assertTrue('x="y"' in pango)
|
||||
self.assertTrue('<span ' in pango)
|
||||
self.assertTrue('>test</span>' in pango)
|
||||
self.assertEqual('pango', self.someBlock.dict()['markup'])
|
||||
self.assertTrue("<span " in pango)
|
||||
self.assertTrue(">test</span>" in pango)
|
||||
self.assertEqual("pango", self.someBlock.dict()["markup"])
|
||||
|
||||
def test_padding(self):
|
||||
self.someBlock.set('padding', '***')
|
||||
self.someBlock.set('full_text', 'test')
|
||||
self.someBlock.set("padding", "***")
|
||||
self.someBlock.set("full_text", "test")
|
||||
|
||||
self.assertEqual('***test***', self.someBlock.dict()['full_text'])
|
||||
self.assertEqual("***test***", self.someBlock.dict()["full_text"])
|
||||
|
||||
def test_pre_suffix(self):
|
||||
self.someBlock.set('padding', '*')
|
||||
self.someBlock.set('prefix', 'pre')
|
||||
self.someBlock.set('suffix', 'suf')
|
||||
self.someBlock.set('full_text', 'test')
|
||||
self.someBlock.set("padding", "*")
|
||||
self.someBlock.set("prefix", "pre")
|
||||
self.someBlock.set("suffix", "suf")
|
||||
self.someBlock.set("full_text", "test")
|
||||
|
||||
self.assertEqual("*pre*test*suf*", self.someBlock.dict()["full_text"])
|
||||
|
||||
self.assertEqual('*pre*test*suf*', self.someBlock.dict()['full_text'])
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
|
|
@ -5,40 +5,24 @@ import core.theme
|
|||
import core.event
|
||||
import core.widget
|
||||
|
||||
|
||||
class theme(unittest.TestCase):
|
||||
def setUp(self):
|
||||
core.event.clear()
|
||||
self.invalidThemeName = 'this-theme-does-not-exist'
|
||||
self.validThemeName = 'default'
|
||||
self.defaultsTheme = {
|
||||
'defaults': {
|
||||
'fg': 'red', 'bg': 'black'
|
||||
}
|
||||
}
|
||||
self.invalidThemeName = "this-theme-does-not-exist"
|
||||
self.validThemeName = "default"
|
||||
self.defaultsTheme = {"defaults": {"fg": "red", "bg": "black"}}
|
||||
self.cycleTheme = {
|
||||
'cycle': [
|
||||
{ 'fg': 'red', 'bg': 'black' },
|
||||
{ 'fg': 'black', 'bg': 'red' },
|
||||
{ 'fg': 'white', 'bg': 'blue' }
|
||||
"cycle": [
|
||||
{"fg": "red", "bg": "black"},
|
||||
{"fg": "black", "bg": "red"},
|
||||
{"fg": "white", "bg": "blue"},
|
||||
]
|
||||
}
|
||||
self.colorTheme = {
|
||||
'colors': [{
|
||||
'red': '#ff0000', 'blue': '#0000ff'
|
||||
}]
|
||||
}
|
||||
self.walTheme = {
|
||||
'colors': ['wal']
|
||||
}
|
||||
self.cycleValueTheme = {
|
||||
'defaults': {
|
||||
'fg': [ 'red', 'green', 'blue' ]
|
||||
}
|
||||
}
|
||||
self.stateTheme = {
|
||||
'warning': { 'fg': 'yellow' },
|
||||
'critical': { 'fg': 'red' }
|
||||
}
|
||||
self.colorTheme = {"colors": [{"red": "#ff0000", "blue": "#0000ff"}]}
|
||||
self.walTheme = {"colors": ["wal"]}
|
||||
self.cycleValueTheme = {"defaults": {"fg": ["red", "green", "blue"]}}
|
||||
self.stateTheme = {"warning": {"fg": "yellow"}, "critical": {"fg": "red"}}
|
||||
|
||||
def test_invalid_theme(self):
|
||||
with self.assertRaises(RuntimeError):
|
||||
|
|
@ -50,82 +34,85 @@ class theme(unittest.TestCase):
|
|||
|
||||
def test_defaults(self):
|
||||
theme = core.theme.Theme(raw_data=self.defaultsTheme)
|
||||
self.assertEqual(self.defaultsTheme['defaults']['fg'], theme.get('fg'))
|
||||
self.assertEqual(self.defaultsTheme['defaults']['bg'], theme.get('bg'))
|
||||
self.assertEqual(self.defaultsTheme["defaults"]["fg"], theme.get("fg"))
|
||||
self.assertEqual(self.defaultsTheme["defaults"]["bg"], theme.get("bg"))
|
||||
|
||||
def test_cycle(self):
|
||||
theme = core.theme.Theme(raw_data=self.cycleTheme)
|
||||
self.assertEqual(None, theme.get('prev-bg'))
|
||||
self.assertEqual(self.cycleTheme['cycle'][0]['fg'], theme.get('fg'))
|
||||
self.assertEqual(self.cycleTheme['cycle'][0]['bg'], theme.get('bg'))
|
||||
core.event.trigger('next-widget')
|
||||
self.assertEqual(self.cycleTheme['cycle'][0]['bg'], theme.get('bg', 'previous'))
|
||||
core.event.trigger('next-widget')
|
||||
self.assertEqual(self.cycleTheme['cycle'][2]['fg'], theme.get('fg'))
|
||||
self.assertEqual(self.cycleTheme['cycle'][2]['bg'], theme.get('bg'))
|
||||
self.assertEqual(None, theme.get("prev-bg"))
|
||||
self.assertEqual(self.cycleTheme["cycle"][0]["fg"], theme.get("fg"))
|
||||
self.assertEqual(self.cycleTheme["cycle"][0]["bg"], theme.get("bg"))
|
||||
core.event.trigger("next-widget")
|
||||
self.assertEqual(self.cycleTheme["cycle"][0]["bg"], theme.get("bg", "previous"))
|
||||
core.event.trigger("next-widget")
|
||||
self.assertEqual(self.cycleTheme["cycle"][2]["fg"], theme.get("fg"))
|
||||
self.assertEqual(self.cycleTheme["cycle"][2]["bg"], theme.get("bg"))
|
||||
|
||||
with unittest.mock.patch('core.output.sys.stdout'):
|
||||
core.event.trigger('draw')
|
||||
self.assertEqual(self.cycleTheme['cycle'][0]['fg'], theme.get('fg'))
|
||||
self.assertEqual(self.cycleTheme['cycle'][0]['bg'], theme.get('bg'))
|
||||
with unittest.mock.patch("core.output.sys.stdout"):
|
||||
core.event.trigger("draw")
|
||||
self.assertEqual(self.cycleTheme["cycle"][0]["fg"], theme.get("fg"))
|
||||
self.assertEqual(self.cycleTheme["cycle"][0]["bg"], theme.get("bg"))
|
||||
|
||||
def test_custom_iconset(self):
|
||||
theme = core.theme.Theme(raw_data=self.defaultsTheme)
|
||||
self.assertNotEqual('aaa', theme.get('padding'))
|
||||
theme = core.theme.Theme(raw_data=self.defaultsTheme, iconset={
|
||||
'defaults': { 'padding': 'aaa' }
|
||||
})
|
||||
self.assertEqual('aaa', theme.get('padding'))
|
||||
self.assertNotEqual("aaa", theme.get("padding"))
|
||||
theme = core.theme.Theme(
|
||||
raw_data=self.defaultsTheme, iconset={"defaults": {"padding": "aaa"}}
|
||||
)
|
||||
self.assertEqual("aaa", theme.get("padding"))
|
||||
|
||||
def test_colors(self):
|
||||
theme = core.theme.Theme(raw_data=self.defaultsTheme)
|
||||
self.assertEqual({}, theme.keywords())
|
||||
theme = core.theme.Theme(raw_data=self.colorTheme)
|
||||
self.assertEqual(self.colorTheme['colors'][0], theme.keywords())
|
||||
self.assertEqual(self.colorTheme["colors"][0], theme.keywords())
|
||||
|
||||
def test_wal_colors(self):
|
||||
with unittest.mock.patch('core.theme.io') as io:
|
||||
with unittest.mock.patch('core.theme.os') as os:
|
||||
with unittest.mock.patch("core.theme.io") as io:
|
||||
with unittest.mock.patch("core.theme.os") as os:
|
||||
os.path.isfile.return_value = True
|
||||
io.open.return_value = unittest.mock.MagicMock()
|
||||
io.open.return_value.__enter__.return_value.read.return_value='''
|
||||
io.open.return_value.__enter__.return_value.read.return_value = """
|
||||
{ "colors": { "red": "#ff0000" } }
|
||||
'''
|
||||
"""
|
||||
|
||||
theme = core.theme.Theme(raw_data=self.walTheme)
|
||||
self.assertEqual({'red': '#ff0000'}, theme.keywords())
|
||||
self.assertEqual({"red": "#ff0000"}, theme.keywords())
|
||||
|
||||
def test_wal_special(self):
|
||||
with unittest.mock.patch('core.theme.io') as io:
|
||||
with unittest.mock.patch('core.theme.os') as os:
|
||||
with unittest.mock.patch("core.theme.io") as io:
|
||||
with unittest.mock.patch("core.theme.os") as os:
|
||||
os.path.isfile.return_value = True
|
||||
io.open.return_value.__enter__.return_value.read.return_value='''
|
||||
io.open.return_value.__enter__.return_value.read.return_value = """
|
||||
{ "special": { "background": "#ff0000" } }
|
||||
'''
|
||||
"""
|
||||
|
||||
theme = core.theme.Theme(raw_data=self.walTheme)
|
||||
self.assertEqual({'background': '#ff0000'}, theme.keywords())
|
||||
self.assertEqual({"background": "#ff0000"}, theme.keywords())
|
||||
|
||||
def test_cycle_value(self):
|
||||
widget = core.widget.Widget()
|
||||
expected = self.cycleValueTheme['defaults']['fg']
|
||||
expected = self.cycleValueTheme["defaults"]["fg"]
|
||||
theme = core.theme.Theme(raw_data=self.cycleValueTheme)
|
||||
|
||||
for i in range(0, len(expected)*3):
|
||||
self.assertEqual(expected[i%len(expected)], theme.get('fg', widget))
|
||||
self.assertEqual(expected[i%len(expected)], theme.get('fg', widget)) # ensure multiple invocations are OK
|
||||
core.event.trigger('draw')
|
||||
for i in range(0, len(expected) * 3):
|
||||
self.assertEqual(expected[i % len(expected)], theme.get("fg", widget))
|
||||
self.assertEqual(
|
||||
expected[i % len(expected)], theme.get("fg", widget)
|
||||
) # ensure multiple invocations are OK
|
||||
core.event.trigger("draw")
|
||||
|
||||
def test_state(self):
|
||||
widget = core.widget.Widget()
|
||||
theme = core.theme.Theme(raw_data=self.stateTheme)
|
||||
|
||||
self.assertEqual(None, theme.get('fg', widget))
|
||||
self.assertEqual(None, theme.get("fg", widget))
|
||||
|
||||
widget.state = types.MethodType(lambda self: ['warning'], widget)
|
||||
self.assertEqual(self.stateTheme['warning']['fg'], theme.get('fg', widget))
|
||||
widget.state = types.MethodType(lambda self: ["warning"], widget)
|
||||
self.assertEqual(self.stateTheme["warning"]["fg"], theme.get("fg", widget))
|
||||
|
||||
widget.state = types.MethodType(lambda self: ["critical"], widget)
|
||||
self.assertEqual(self.stateTheme["critical"]["fg"], theme.get("fg", widget))
|
||||
|
||||
widget.state = types.MethodType(lambda self: ['critical'], widget)
|
||||
self.assertEqual(self.stateTheme['critical']['fg'], theme.get('fg', widget))
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@ import core.widget
|
|||
import core.module
|
||||
import core.config
|
||||
|
||||
|
||||
class TestModule(core.module.Module):
|
||||
def __init__(self, widgets, config=core.config.Config([]), theme=None):
|
||||
super().__init__(config, theme, widgets)
|
||||
|
|
@ -18,13 +19,16 @@ class TestModule(core.module.Module):
|
|||
def state(self, widget):
|
||||
return self.states
|
||||
|
||||
|
||||
class widget(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.someValue = 'some random value'
|
||||
self.someOtherValue = 'some different value'
|
||||
self.callbackReturnValue = 'callback return value'
|
||||
self.someValue = "some random value"
|
||||
self.someOtherValue = "some different value"
|
||||
self.callbackReturnValue = "callback return value"
|
||||
self.someWidget = core.widget.Widget(full_text=self.someValue)
|
||||
self.someCallback = unittest.mock.MagicMock(return_value=self.callbackReturnValue)
|
||||
self.someCallback = unittest.mock.MagicMock(
|
||||
return_value=self.callbackReturnValue
|
||||
)
|
||||
|
||||
self.assertNotEqual(self.someValue, self.someOtherValue)
|
||||
|
||||
|
|
@ -54,38 +58,38 @@ class widget(unittest.TestCase):
|
|||
self.assertEqual([], self.someWidget.state())
|
||||
|
||||
def test_single_widget_state(self):
|
||||
self.someWidget.set('state', 'state1')
|
||||
self.assertEqual(['state1'], self.someWidget.state())
|
||||
self.someWidget.set("state", "state1")
|
||||
self.assertEqual(["state1"], self.someWidget.state())
|
||||
|
||||
def test_multiple_widget_states(self):
|
||||
self.someWidget.set('state', ['state1', 'state2'])
|
||||
self.assertEqual(['state1', 'state2'], self.someWidget.state())
|
||||
self.someWidget.set("state", ["state1", "state2"])
|
||||
self.assertEqual(["state1", "state2"], self.someWidget.state())
|
||||
|
||||
def test_widget_module_state(self):
|
||||
module = TestModule(widgets=self.someWidget)
|
||||
self.someWidget.set('state', ['state1', 'state2'])
|
||||
self.someWidget.set("state", ["state1", "state2"])
|
||||
|
||||
module.states = 'x'
|
||||
self.assertEqual(['state1', 'state2', 'x'], self.someWidget.state())
|
||||
module.states = ['a', 'b']
|
||||
self.assertEqual(['state1', 'state2', 'a', 'b'], self.someWidget.state())
|
||||
module.states = "x"
|
||||
self.assertEqual(["state1", "state2", "x"], self.someWidget.state())
|
||||
module.states = ["a", "b"]
|
||||
self.assertEqual(["state1", "state2", "a", "b"], self.someWidget.state())
|
||||
|
||||
def test_multiple_widget_themes(self):
|
||||
widget1 = core.widget.Widget(full_text='a')
|
||||
widget2 = core.widget.Widget(full_text='b')
|
||||
widget3 = core.widget.Widget(full_text='c')
|
||||
widget1 = core.widget.Widget(full_text="a")
|
||||
widget2 = core.widget.Widget(full_text="b")
|
||||
widget3 = core.widget.Widget(full_text="c")
|
||||
|
||||
module = TestModule(widgets=[widget1, widget2, widget3])
|
||||
module.set('theme.test', '1,2,3')
|
||||
module.set('theme.test2', 'x')
|
||||
module.set("theme.test", "1,2,3")
|
||||
module.set("theme.test2", "x")
|
||||
|
||||
self.assertEqual('1', widget1.theme('test'))
|
||||
self.assertEqual('2', widget2.theme('test'))
|
||||
self.assertEqual('3', widget3.theme('test'))
|
||||
self.assertEqual("1", widget1.theme("test"))
|
||||
self.assertEqual("2", widget2.theme("test"))
|
||||
self.assertEqual("3", widget3.theme("test"))
|
||||
|
||||
self.assertEqual('x', widget1.theme('test2'))
|
||||
self.assertEqual(None, widget2.theme('test2'))
|
||||
self.assertEqual(None, widget3.theme('test2'))
|
||||
self.assertEqual("x", widget1.theme("test2"))
|
||||
self.assertEqual(None, widget2.theme("test2"))
|
||||
self.assertEqual(None, widget3.theme("test2"))
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
|
|
@ -3,15 +3,19 @@ import unittest
|
|||
import core.config
|
||||
import modules.core.kernel
|
||||
|
||||
|
||||
class kernel(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.someKernel = 'this-is-my-kernel'
|
||||
self.module = modules.core.kernel.Module(config=core.config.Config([]), theme=None)
|
||||
self.someKernel = "this-is-my-kernel"
|
||||
self.module = modules.core.kernel.Module(
|
||||
config=core.config.Config([]), theme=None
|
||||
)
|
||||
|
||||
def test_full_text(self):
|
||||
with unittest.mock.patch('modules.core.kernel.platform') as platform:
|
||||
with unittest.mock.patch("modules.core.kernel.platform") as platform:
|
||||
platform.release.return_value = self.someKernel
|
||||
self.assertEqual(1, len(self.module.widgets()))
|
||||
self.assertEqual(self.someKernel, self.module.widget().full_text())
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
|
|
@ -2,12 +2,13 @@ import unittest
|
|||
|
||||
from util.algorithm import *
|
||||
|
||||
|
||||
class algorithm(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.someData = {'a': 100, 'b': 200, 'c': [1,2,3]}
|
||||
self.differentData = {'x': 20, 'y': 'bla', 'z': ['a','b']}
|
||||
self.moreData = {'n': 100}
|
||||
self.overlapData = {'a': 200, 'c': [1,2,4]}
|
||||
self.someData = {"a": 100, "b": 200, "c": [1, 2, 3]}
|
||||
self.differentData = {"x": 20, "y": "bla", "z": ["a", "b"]}
|
||||
self.moreData = {"n": 100}
|
||||
self.overlapData = {"a": 200, "c": [1, 2, 4]}
|
||||
|
||||
def test_merge_with_empty(self):
|
||||
self.assertEqual(self.someData, merge(self.someData, {}))
|
||||
|
|
@ -37,4 +38,5 @@ class algorithm(unittest.TestCase):
|
|||
for k in self.overlapData:
|
||||
self.assertEqual(result[k], self.overlapData[k])
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
|
|
@ -2,13 +2,14 @@ import unittest
|
|||
|
||||
import util.cli
|
||||
|
||||
|
||||
class cli(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.nonExistentCommand = 'i-do-not-exist'
|
||||
self.validCommand = 'echo test'
|
||||
self.validCommandOutput = 'test\n'
|
||||
self.utfCommand = 'echo ÖPmŧß'
|
||||
self.utfCommandOutput = 'ÖPmŧß\n'
|
||||
self.nonExistentCommand = "i-do-not-exist"
|
||||
self.validCommand = "echo test"
|
||||
self.validCommandOutput = "test\n"
|
||||
self.utfCommand = "echo ÖPmŧß"
|
||||
self.utfCommandOutput = "ÖPmŧß\n"
|
||||
|
||||
def test_valid_command(self):
|
||||
rv = util.cli.execute(self.validCommand)
|
||||
|
|
@ -24,16 +25,19 @@ class cli(unittest.TestCase):
|
|||
|
||||
def test_command_exit_code(self):
|
||||
with self.assertRaises(RuntimeError):
|
||||
util.cli.execute('cat {}'.format(self.nonExistentCommand))
|
||||
util.cli.execute("cat {}".format(self.nonExistentCommand))
|
||||
|
||||
def test_command_exit_code_no_error(self):
|
||||
try:
|
||||
util.cli.execute('cat {}'.format(self.nonExistentCommand), ignore_errors=True)
|
||||
util.cli.execute(
|
||||
"cat {}".format(self.nonExistentCommand), ignore_errors=True
|
||||
)
|
||||
except Exception:
|
||||
self.fail('exception was thrown')
|
||||
self.fail("exception was thrown")
|
||||
|
||||
def test_async(self):
|
||||
rv = util.cli.execute(self.validCommand, wait=False)
|
||||
self.assertEqual('', rv)
|
||||
self.assertEqual("", rv)
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
|
|
@ -2,11 +2,12 @@ import unittest
|
|||
|
||||
from util.format import *
|
||||
|
||||
|
||||
class format(unittest.TestCase):
|
||||
def test_int_from_string(self):
|
||||
self.assertEqual(100, asint('100'))
|
||||
self.assertEqual(-100, asint('-100'))
|
||||
self.assertEqual(0, asint('0'))
|
||||
self.assertEqual(100, asint("100"))
|
||||
self.assertEqual(-100, asint("-100"))
|
||||
self.assertEqual(0, asint("0"))
|
||||
|
||||
def test_int_from_none(self):
|
||||
self.assertEqual(0, asint(None))
|
||||
|
|
@ -27,73 +28,76 @@ class format(unittest.TestCase):
|
|||
self.assertEqual(100, asint(200, maximum=100))
|
||||
|
||||
def test_true_from_str(self):
|
||||
self.assertTrue(asbool('true'))
|
||||
self.assertTrue(asbool("true"))
|
||||
self.assertTrue(asbool(True))
|
||||
self.assertTrue(asbool('t'))
|
||||
self.assertTrue(asbool('1'))
|
||||
self.assertTrue(asbool('yes'))
|
||||
self.assertTrue(asbool('y'))
|
||||
self.assertTrue(asbool('on'))
|
||||
self.assertTrue(asbool("t"))
|
||||
self.assertTrue(asbool("1"))
|
||||
self.assertTrue(asbool("yes"))
|
||||
self.assertTrue(asbool("y"))
|
||||
self.assertTrue(asbool("on"))
|
||||
|
||||
def test_false_from_str(self):
|
||||
self.assertFalse(asbool('false'))
|
||||
self.assertFalse(asbool("false"))
|
||||
self.assertFalse(asbool(False))
|
||||
self.assertFalse(asbool('f'))
|
||||
self.assertFalse(asbool('0'))
|
||||
self.assertFalse(asbool('no'))
|
||||
self.assertFalse(asbool('n'))
|
||||
self.assertFalse(asbool('off'))
|
||||
self.assertFalse(asbool("f"))
|
||||
self.assertFalse(asbool("0"))
|
||||
self.assertFalse(asbool("no"))
|
||||
self.assertFalse(asbool("n"))
|
||||
self.assertFalse(asbool("off"))
|
||||
self.assertFalse(asbool(None))
|
||||
|
||||
def test_list_from_None(self):
|
||||
self.assertEqual([], aslist(None))
|
||||
|
||||
def test_list_from_list(self):
|
||||
self.assertEqual([1,2,3], aslist([1,2,3]))
|
||||
self.assertEqual([1, 2, 3], aslist([1, 2, 3]))
|
||||
|
||||
def test_list_from_str(self):
|
||||
self.assertEqual(['12', '13', '14'], aslist('12,13,14'))
|
||||
self.assertEqual(["12", "13", "14"], aslist("12,13,14"))
|
||||
|
||||
def test_byteformat(self):
|
||||
self.assertEqual('500.00B', byte(500))
|
||||
self.assertEqual('1.00KiB', byte(1024))
|
||||
self.assertEqual('1KiB', byte(1024, '{:.0f}'))
|
||||
self.assertEqual('1.50KiB', byte(1024+512))
|
||||
self.assertEqual('2.50MiB', byte(1024*1024*2 + 1024*512))
|
||||
self.assertEqual('4.50GiB', byte(1024*1024*1024*4 + 1024*1024*512))
|
||||
self.assertEqual('2048.00GiB', byte(1024*1024*1024*1024*2))
|
||||
self.assertEqual("500.00B", byte(500))
|
||||
self.assertEqual("1.00KiB", byte(1024))
|
||||
self.assertEqual("1KiB", byte(1024, "{:.0f}"))
|
||||
self.assertEqual("1.50KiB", byte(1024 + 512))
|
||||
self.assertEqual("2.50MiB", byte(1024 * 1024 * 2 + 1024 * 512))
|
||||
self.assertEqual("4.50GiB", byte(1024 * 1024 * 1024 * 4 + 1024 * 1024 * 512))
|
||||
self.assertEqual("2048.00GiB", byte(1024 * 1024 * 1024 * 1024 * 2))
|
||||
|
||||
def test_duration(self):
|
||||
self.assertEqual('04:20:00', duration(4*60*60+20*60))
|
||||
self.assertEqual('04:20:00h', duration(4*60*60+20*60, unit=True))
|
||||
self.assertEqual('04:20h', duration(4*60*60+20*60, compact=True, unit=True))
|
||||
self.assertEqual("04:20:00", duration(4 * 60 * 60 + 20 * 60))
|
||||
self.assertEqual("04:20:00h", duration(4 * 60 * 60 + 20 * 60, unit=True))
|
||||
self.assertEqual(
|
||||
"04:20h", duration(4 * 60 * 60 + 20 * 60, compact=True, unit=True)
|
||||
)
|
||||
|
||||
self.assertEqual('20:00', duration(20*60))
|
||||
self.assertEqual('20:00m', duration(20*60, unit=True))
|
||||
self.assertEqual('20:00m', duration(20*60, compact=True, unit=True))
|
||||
self.assertEqual("20:00", duration(20 * 60))
|
||||
self.assertEqual("20:00m", duration(20 * 60, unit=True))
|
||||
self.assertEqual("20:00m", duration(20 * 60, compact=True, unit=True))
|
||||
|
||||
self.assertEqual('00:20', duration(20))
|
||||
self.assertEqual('00:20m', duration(20, unit=True))
|
||||
self.assertEqual('00:20m', duration(20, compact=True, unit=True))
|
||||
self.assertEqual("00:20", duration(20))
|
||||
self.assertEqual("00:20m", duration(20, unit=True))
|
||||
self.assertEqual("00:20m", duration(20, compact=True, unit=True))
|
||||
|
||||
self.assertEqual('n/a', duration(-1))
|
||||
self.assertEqual("n/a", duration(-1))
|
||||
|
||||
def test_seconds(self):
|
||||
self.assertEqual(10, seconds(10))
|
||||
self.assertEqual(10, seconds('10'))
|
||||
self.assertEqual(10, seconds("10"))
|
||||
|
||||
self.assertEqual(300, seconds('5m'))
|
||||
self.assertEqual(320, seconds('5m20s'))
|
||||
self.assertEqual(300, seconds("5m"))
|
||||
self.assertEqual(320, seconds("5m20s"))
|
||||
|
||||
self.assertEqual(4*3600, seconds('4h'))
|
||||
self.assertEqual(4*3600 + 5*60 + 22, seconds('4h5m22s'))
|
||||
self.assertEqual(4 * 3600, seconds("4h"))
|
||||
self.assertEqual(4 * 3600 + 5 * 60 + 22, seconds("4h5m22s"))
|
||||
|
||||
self.assertEqual(4*3600 + 5*60, seconds('4h5m'))
|
||||
self.assertEqual(4 * 3600 + 5 * 60, seconds("4h5m"))
|
||||
|
||||
def test_temperature(self):
|
||||
self.assertEqual('10°C', astemperature(10))
|
||||
self.assertEqual('10°C', astemperature(10, 'metric'))
|
||||
self.assertEqual('-100°F', astemperature(-100, 'imperial'))
|
||||
self.assertEqual('-100°K', astemperature('-100', 'kelvin'))
|
||||
self.assertEqual("10°C", astemperature(10))
|
||||
self.assertEqual("10°C", astemperature(10, "metric"))
|
||||
self.assertEqual("-100°F", astemperature(-100, "imperial"))
|
||||
self.assertEqual("-100°K", astemperature("-100", "kelvin"))
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
|
|
@ -4,40 +4,48 @@ import urllib.request
|
|||
|
||||
import util.location
|
||||
|
||||
|
||||
class location(unittest.TestCase):
|
||||
def setUp(self):
|
||||
patcher = unittest.mock.patch('util.location.urllib.request')
|
||||
patcher = unittest.mock.patch("util.location.urllib.request")
|
||||
self.addCleanup(patcher.stop)
|
||||
self.request = patcher.start()
|
||||
util.location.reset()
|
||||
|
||||
self.primary = {
|
||||
'country': 'Middle Earth',
|
||||
'longitude': '10.0',
|
||||
'latitude': '20.5',
|
||||
'ip': '127.0.0.1',
|
||||
"country": "Middle Earth",
|
||||
"longitude": "10.0",
|
||||
"latitude": "20.5",
|
||||
"ip": "127.0.0.1",
|
||||
}
|
||||
self.secondary = {
|
||||
'country_name': 'Rivia',
|
||||
'longitude': '-10.0',
|
||||
'latitude': '-23',
|
||||
'ip': '127.0.0.6',
|
||||
"country_name": "Rivia",
|
||||
"longitude": "-10.0",
|
||||
"latitude": "-23",
|
||||
"ip": "127.0.0.6",
|
||||
}
|
||||
|
||||
def test_primary_provider(self):
|
||||
self.request.urlopen.return_value.read.return_value = json.dumps(self.primary)
|
||||
util.location.country()
|
||||
self.assertEqual(self.primary['country'], util.location.country())
|
||||
self.assertEqual((self.primary['latitude'], self.primary['longitude']), util.location.coordinates())
|
||||
self.assertEqual(self.primary['ip'], util.location.public_ip())
|
||||
self.assertEqual(self.primary["country"], util.location.country())
|
||||
self.assertEqual(
|
||||
(self.primary["latitude"], self.primary["longitude"]),
|
||||
util.location.coordinates(),
|
||||
)
|
||||
self.assertEqual(self.primary["ip"], util.location.public_ip())
|
||||
|
||||
def test_secondary_provider(self):
|
||||
urlopen = unittest.mock.MagicMock()
|
||||
urlopen.read.return_value = json.dumps(self.secondary)
|
||||
self.request.urlopen.side_effect = [ RuntimeError(), urlopen ]
|
||||
self.request.urlopen.side_effect = [RuntimeError(), urlopen]
|
||||
|
||||
self.assertEqual(self.secondary["country_name"], util.location.country())
|
||||
self.assertEqual(
|
||||
(self.secondary["latitude"], self.secondary["longitude"]),
|
||||
util.location.coordinates(),
|
||||
)
|
||||
self.assertEqual(self.secondary["ip"], util.location.public_ip())
|
||||
|
||||
self.assertEqual(self.secondary['country_name'], util.location.country())
|
||||
self.assertEqual((self.secondary['latitude'], self.secondary['longitude']), util.location.coordinates())
|
||||
self.assertEqual(self.secondary['ip'], util.location.public_ip())
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@ import unittest
|
|||
|
||||
import util.store
|
||||
|
||||
|
||||
class store(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.store = util.store.Store()
|
||||
|
|
@ -13,14 +14,24 @@ class store(unittest.TestCase):
|
|||
self.someOtherValue = "anotherRandomValue"
|
||||
|
||||
def test_get_of_unset_key(self):
|
||||
self.assertEqual(None, self.store.get(self.unusedKey), 'default value expected to be None')
|
||||
self.assertEqual(self.someValue, self.store.get(self.unusedKey, self.someValue), 'wrong user-provided default value returned')
|
||||
self.assertEqual(
|
||||
None, self.store.get(self.unusedKey), "default value expected to be None"
|
||||
)
|
||||
self.assertEqual(
|
||||
self.someValue,
|
||||
self.store.get(self.unusedKey, self.someValue),
|
||||
"wrong user-provided default value returned",
|
||||
)
|
||||
|
||||
def test_get_of_set_key(self):
|
||||
self.assertNotEqual(self.someValue, None)
|
||||
|
||||
self.store.set(self.someKey, self.someValue)
|
||||
self.assertEqual(self.someValue, self.store.get(self.someKey), 'unexpected value for existing key')
|
||||
self.assertEqual(
|
||||
self.someValue,
|
||||
self.store.get(self.someKey),
|
||||
"unexpected value for existing key",
|
||||
)
|
||||
|
||||
def test_overwrite_set(self):
|
||||
self.assertNotEqual(self.someValue, None)
|
||||
|
|
@ -28,7 +39,11 @@ class store(unittest.TestCase):
|
|||
|
||||
self.store.set(self.someKey, self.someValue)
|
||||
self.store.set(self.someKey, self.someOtherValue)
|
||||
self.assertEqual(self.someOtherValue, self.store.get(self.someKey), 'unexpected value for existing key')
|
||||
self.assertEqual(
|
||||
self.someOtherValue,
|
||||
self.store.get(self.someKey),
|
||||
"unexpected value for existing key",
|
||||
)
|
||||
|
||||
def test_unused_keys(self):
|
||||
self.assertNotEqual(self.someKey, self.someOtherKey)
|
||||
|
|
@ -36,9 +51,12 @@ class store(unittest.TestCase):
|
|||
self.store.set(self.someKey, self.someValue)
|
||||
self.store.set(self.someOtherKey, self.someOtherValue)
|
||||
|
||||
self.assertEqual(sorted(self.store.unused_keys()), sorted([self.someKey, self.someOtherKey]))
|
||||
self.assertEqual(
|
||||
sorted(self.store.unused_keys()), sorted([self.someKey, self.someOtherKey])
|
||||
)
|
||||
|
||||
self.store.get(self.someKey)
|
||||
self.assertEqual(self.store.unused_keys(), [self.someOtherKey])
|
||||
|
||||
|
||||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue