mirror of
https://github.com/gryf/weechat-replacer.git
synced 2025-12-17 19:40:20 +01:00
325 lines
10 KiB
Python
325 lines
10 KiB
Python
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
import sys
|
|
import os
|
|
import unittest
|
|
from unittest import mock
|
|
import tempfile
|
|
|
|
|
|
class Weechat(object):
|
|
"""Mock weechat interface"""
|
|
ACTION = '*'
|
|
ERROR = '=!='
|
|
NETWORK = '--'
|
|
JOIN = '-->'
|
|
QUIT = '<--'
|
|
WEECHAT_RC_OK = 0
|
|
WEECHAT_LIST_POS_SORT = 1
|
|
|
|
def __init__(self):
|
|
self.wbuffer = ''
|
|
self.completions = []
|
|
self.position = 0
|
|
self.line = ''
|
|
|
|
def register(self, *args, **kwargs):
|
|
pass
|
|
|
|
def color(self, color):
|
|
return color
|
|
|
|
def prnt(self, we_buff, msg):
|
|
self.wbuffer = msg
|
|
|
|
def prefix(self, arg):
|
|
_map = {'action': Weechat.ACTION,
|
|
'error': Weechat.ERROR,
|
|
'network': Weechat.NETWORK,
|
|
'join': Weechat.JOIN,
|
|
'quit': Weechat.QUIT}
|
|
return _map[arg]
|
|
|
|
def hook_completion(self, *args, **kwargs):
|
|
pass
|
|
|
|
def hook_command(self, *args, **kwargs):
|
|
pass
|
|
|
|
def hook_completion_list_add(self, completion, item, index, sort):
|
|
self.completions.append(item)
|
|
|
|
def buffer_get_integer(self, *args, **kwargs):
|
|
return self.position
|
|
|
|
def buffer_get_string(self, *args, **kwargs):
|
|
return self.line
|
|
|
|
def buffer_set(self, wbuffer, what, value):
|
|
_map = {'input': self._set_line,
|
|
'input_pos': self._set_position}
|
|
_map[what](value)
|
|
|
|
def _set_line(self, val):
|
|
self.line = val
|
|
|
|
def _set_position(self, val):
|
|
self.position = val
|
|
|
|
def string_eval_path_home(self, path, pointers, extra_vars, options):
|
|
return path
|
|
|
|
def info_get(self, key, args):
|
|
_map = {'weechat_data_dir': None,
|
|
'weechat_config_dir': None,
|
|
'version_number': 0x3020000}
|
|
return _map.get(key)
|
|
|
|
|
|
weechat = Weechat()
|
|
sys.modules['weechat'] = weechat
|
|
|
|
|
|
import replacer
|
|
|
|
|
|
class TestReplacer(unittest.TestCase):
|
|
|
|
@mock.patch('replacer.Replacer._locate_replacement_file')
|
|
def setUp(self, rfile):
|
|
fd, fname = tempfile.mkstemp()
|
|
os.close(fd)
|
|
rfile.return_value = fname
|
|
self._path = fname
|
|
self.repl = replacer.Replacer()
|
|
|
|
def tearDown(self):
|
|
self.repl = None
|
|
try:
|
|
os.unlink(self._path)
|
|
except OSError:
|
|
pass
|
|
|
|
def test_init(self):
|
|
self.assertDictEqual(self.repl.replacement_map, {})
|
|
|
|
def test_add(self):
|
|
self.repl.add('foo', 'bar')
|
|
self.assertDictEqual(self.repl.replacement_map, {'foo': 'bar'})
|
|
|
|
def test_delete(self):
|
|
self.repl.add('foo', 'bar')
|
|
self.assertFalse(self.repl.delete('baz'))
|
|
self.assertTrue(self.repl.delete('foo'))
|
|
self.assertDictEqual(self.repl.replacement_map, {})
|
|
|
|
|
|
class TestDummyTests(unittest.TestCase):
|
|
"""
|
|
This, somehow stupid test ensures, that process of reading default
|
|
replacer config file works
|
|
"""
|
|
def tearDown(self):
|
|
replacer.Replacer.self_object = None
|
|
|
|
@mock.patch('replacer.Replacer._locate_replacement_file')
|
|
def test_init(self, rfile):
|
|
rfile.return_value = 'dummy_path'
|
|
repl = replacer.Replacer()
|
|
self.assertIsInstance(repl.replacement_map, dict)
|
|
|
|
@mock.patch('replacer.Replacer._locate_replacement_file')
|
|
def test_main(self, rfile):
|
|
rfile.return_value = 'dummy_path'
|
|
replacer.Replacer.self_object = replacer.Replacer()
|
|
replacer.main()
|
|
|
|
@mock.patch('replacer.Replacer._locate_replacement_file')
|
|
def test_injector(self, rfile):
|
|
|
|
rfile.return_value = 'dummy_path'
|
|
|
|
def fun(first, *args, **kwargs):
|
|
return first
|
|
|
|
self.assertIsNone(replacer.Replacer.self_object)
|
|
robj = replacer.inject_replacer_object(fun)()
|
|
self.assertIsNotNone(replacer.Replacer.self_object)
|
|
self.assertIsInstance(robj, replacer.Replacer)
|
|
|
|
|
|
class TestFunctions(unittest.TestCase):
|
|
|
|
@mock.patch('replacer.Replacer._locate_replacement_file')
|
|
def setUp(self, rfile):
|
|
fd, fname = tempfile.mkstemp()
|
|
os.close(fd)
|
|
self._path = fname
|
|
rfile.return_value = fname
|
|
replacer.Replacer.self_object = replacer.Replacer()
|
|
self.rc = replacer.Replacer
|
|
|
|
def tearDown(self):
|
|
self.rc.self_object = None
|
|
try:
|
|
os.unlink(self._path)
|
|
except OSError:
|
|
pass
|
|
weechat.completions = []
|
|
|
|
def test_echo(self):
|
|
replacer.echo('a', None)
|
|
self.assertEqual(weechat.wbuffer, 'a')
|
|
|
|
replacer.echo('a', None, 'action')
|
|
self.assertEqual(weechat.wbuffer, '%sa' % Weechat.ACTION)
|
|
replacer.echo('something', None, 'network')
|
|
self.assertEqual(weechat.wbuffer, '%ssomething' % Weechat.NETWORK)
|
|
|
|
def test_replace_cmd(self):
|
|
replacer.replace_cmd(None, None, None)
|
|
self.assertIn(Weechat.ERROR, weechat.wbuffer)
|
|
self.assertIn('No replacements defined', weechat.wbuffer)
|
|
|
|
self.rc.self_object.replacement_map = {'foo': 'bar'}
|
|
|
|
replacer.replace_cmd(None, None, None)
|
|
self.assertEqual(weechat.wbuffer, 'foo chat_delimiters->reset bar')
|
|
|
|
args = 'foo bar bazz'
|
|
replacer.replace_cmd(None, None, args)
|
|
self.assertIn(Weechat.ERROR, weechat.wbuffer)
|
|
self.assertIn('Error in command', weechat.wbuffer)
|
|
|
|
args = 'add baz bazz'
|
|
replacer.replace_cmd(None, None, args)
|
|
self.assertEqual(weechat.wbuffer,
|
|
'--added: baz chat_delimiters->reset bazz')
|
|
self.assertDictEqual(self.rc.self_object.replacement_map,
|
|
{'foo': 'bar', 'baz': 'bazz'})
|
|
|
|
args = 'del baz'
|
|
replacer.replace_cmd(None, None, args)
|
|
self.assertEqual(weechat.wbuffer, '--Successfully removed key: baz')
|
|
|
|
args = 'del baz'
|
|
replacer.replace_cmd(None, None, args)
|
|
self.assertIn(Weechat.ERROR, weechat.wbuffer)
|
|
self.assertIn('No such keyword', weechat.wbuffer)
|
|
|
|
def test_completion_cb(self):
|
|
replacer.completion_cb(None, None, None, None)
|
|
|
|
self.rc.self_object.replacement_map = {'foo': 'bar'}
|
|
|
|
replacer.completion_cb(None, None, None, None)
|
|
self.assertEqual(weechat.completions, ['foo'])
|
|
|
|
def test_replace_cb(self):
|
|
replacer.replace_cb(None, None, None, None)
|
|
self.assertEqual(weechat.position, 0)
|
|
self.assertEqual(weechat.line, '')
|
|
|
|
self.rc.self_object.replacement_map = {'foo': 'Vestibulum ante'}
|
|
|
|
# quis foo cursus
|
|
# ^
|
|
weechat.line = 'quis foo cursus'
|
|
weechat.position = 8
|
|
replacer.replace_cb(None, None, None, None)
|
|
self.assertEqual(weechat.line, 'quis Vestibulum ante cursus')
|
|
|
|
# quis cursus foo
|
|
# ^
|
|
weechat.line = 'quis cursus foo'
|
|
weechat.position = 15
|
|
replacer.replace_cb(None, None, None, None)
|
|
self.assertEqual(weechat.line, 'quis cursus Vestibulum ante ')
|
|
|
|
# foo quis cursus
|
|
# ^
|
|
weechat.line = 'foo quis cursus'
|
|
weechat.position = 3
|
|
replacer.replace_cb(None, None, None, None)
|
|
self.assertEqual(weechat.line, 'Vestibulum ante quis cursus')
|
|
|
|
# quis cursus
|
|
# ^
|
|
weechat.line = 'quis cursus'
|
|
weechat.position = 5
|
|
replacer.replace_cb(None, None, None, None)
|
|
self.assertEqual(weechat.line, 'quis cursus')
|
|
|
|
|
|
class TestLocateWeeHome(unittest.TestCase):
|
|
|
|
@mock.patch('os.path.exists')
|
|
@mock.patch('weechat.string_eval_path_home')
|
|
@mock.patch('weechat.info_get')
|
|
def test_locate_replacement_file_data_dir(self, info_get, eval_path_home,
|
|
path_exists):
|
|
info_get.side_effect = ('foo', 'bar')
|
|
eval_path_home.side_effect = ('baz', )
|
|
path_exists.side_effect = (True, )
|
|
|
|
result = replacer.Replacer._locate_replacement_file(object)
|
|
|
|
self.assertEqual(result, 'foo/replacement_map.json')
|
|
|
|
@mock.patch('os.path.exists')
|
|
@mock.patch('weechat.string_eval_path_home')
|
|
@mock.patch('weechat.info_get')
|
|
def test_locate_replacement_file_config_dir(self, info_get, eval_path_home,
|
|
path_exists):
|
|
info_get.side_effect = ('foo', 'bar')
|
|
eval_path_home.side_effect = ('baz', )
|
|
path_exists.side_effect = (False, True)
|
|
|
|
result = replacer.Replacer._locate_replacement_file(object)
|
|
|
|
self.assertEqual(result, 'bar/replacement_map.json')
|
|
|
|
@mock.patch('os.path.exists')
|
|
@mock.patch('weechat.string_eval_path_home')
|
|
@mock.patch('weechat.info_get')
|
|
def test_locate_replacement_file_old_home(self, info_get, eval_path_home,
|
|
path_exists):
|
|
info_get.side_effect = ('foo', 'bar')
|
|
eval_path_home.side_effect = ('baz', )
|
|
path_exists.side_effect = (False, False, True)
|
|
|
|
result = replacer.Replacer._locate_replacement_file(object)
|
|
|
|
self.assertEqual(result, 'baz/replacement_map.json')
|
|
|
|
@mock.patch('os.path.exists')
|
|
@mock.patch('weechat.string_eval_path_home')
|
|
@mock.patch('weechat.info_get')
|
|
def test_locate_replacement_default_home_31(self, info_get, eval_path_home,
|
|
path_exists):
|
|
info_get.side_effect = ('foo', 'bar', 0x3010000)
|
|
eval_path_home.side_effect = ('baz', 'old/replacement_map.json')
|
|
path_exists.side_effect = (False, False, False)
|
|
|
|
result = replacer.Replacer._locate_replacement_file(object)
|
|
|
|
self.assertEqual(result, 'old/replacement_map.json')
|
|
|
|
@mock.patch('os.path.exists')
|
|
@mock.patch('weechat.string_eval_path_home')
|
|
@mock.patch('weechat.info_get')
|
|
def test_locate_replacement_default_home_32(self, info_get, eval_path_home,
|
|
path_exists):
|
|
info_get.side_effect = ('foo', 'bar', 0x3020000, 'new')
|
|
eval_path_home.side_effect = ('baz', )
|
|
path_exists.side_effect = (False, False, False)
|
|
|
|
result = replacer.Replacer._locate_replacement_file(object)
|
|
|
|
self.assertEqual(result, 'new/replacement_map.json')
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|