def test_add_argument_dest_exception(self):
def cmd_process(args, sender):
pass
lap = LinotArgParser('testcmd', self.parser, cmd_process)
with assert_raises(ValueError):
lap.add_argument('-a', dest='b', action='store_true')
def test_add_argument_exclusiveness(self):
def cmd_process(args, sender):
ok_((args.a and args.b) is False)
lap = LinotArgParser('testcmd', self.parser, cmd_process)
lap.add_argument('-a', action='store_true')
lap.add_argument('-b', action='store_true')
with assert_raises(SystemExit) as e:
args, unknown_args = self.parser.parse_known_args('testcmd -a -b'.split())
check_str = 'not allowed with'
ok_(check_str in e.msg)
def test_add_argument_exclusiveness(self):
def cmd_process(args, sender):
ok_((args.a and args.b) is False)
lap = LinotArgParser('testcmd', self.parser, cmd_process)
lap.add_argument('-a', action='store_true')
lap.add_argument('-b', action='store_true')
with assert_raises(SystemExit) as e:
args, unknown_args = self.parser.parse_known_args(
'testcmd -a -b'.split())
check_str = 'not allowed with'
ok_(check_str in e.msg)
def test_direct_command(self):
def cmd_checker1(match_list, cmd, sender):
cmd_checker1.runned = True
cmd_checker1.cmd = cmd
ok_('1234' in match_list)
def cmd_checker2(match_list, cmd, sender):
cmd_checker2.runned = True
cmd_checker2.cmd = cmd
ok_('1234' in match_list)
# Here we only test the api correctness
# the integration test will be in command_server test
ap = LinotArgParser('testcmd', self.parser, None)
ap.add_direct_command(cmd_checker1, '[cxyz]+([0-9]+)', re.IGNORECASE)
ap = LinotArgParser('testcmd2', self.parser, None)
ap.add_direct_command(cmd_checker2, '[abc]+([0-9]+)', re.IGNORECASE)
cmd_checker1.runned = False
cmd_checker2.runned = False
self.parser.process_direct_commands('1234', None)
ok_(cmd_checker1.runned is False)
ok_(cmd_checker2.runned is False)
self.parser.process_direct_commands('xyz1234', None)
ok_(cmd_checker1.runned is True)
ok_(cmd_checker2.runned is False)
cmd_checker1.runned = False
self.parser.process_direct_commands('ab1234', None)
ok_(cmd_checker1.runned is False)
ok_(cmd_checker2.runned is True)
cmd_checker2.runned = False
self.parser.process_direct_commands('c1234', None)
ok_(cmd_checker1.runned is True)
ok_(cmd_checker2.runned is True)
ok_(cmd_checker1.cmd == 'c1234')
ok_(cmd_checker2.cmd == 'c1234')
def test_add_argument_func(self):
def cmd_process(args, sender):
ok_(args.b and not sender)
def cust_func(value, sender):
ok_(value and sender)
lap = LinotArgParser('testcmd', self.parser, cmd_process)
lap.add_argument('-a', action='store_true', func=cust_func)
lap.add_argument('-b', action='store_true') # default proc
args, unknown_args = self.parser.parse_known_args('testcmd -a'.split())
args.proc(args, True)
args, unknown_args = self.parser.parse_known_args('testcmd -b'.split())
args.proc(args, False)
def test_add_argument_multiargs(self):
def cmd_process(args, sender):
ok_(False)
def cust_func(value, sender):
ok_(value)
cust_func.called += 1
cust_func.called = 0
lap = LinotArgParser('testcmd', self.parser, cmd_process)
lap.add_argument('-a', '-b', '-c', action='store_true', func=cust_func)
args, unkown_args = self.parser.parse_known_args('testcmd -a'.split())
args.proc(args, None)
args, unkown_args = self.parser.parse_known_args('testcmd -b'.split())
args.proc(args, None)
args, unkown_args = self.parser.parse_known_args('testcmd -c'.split())
args.proc(args, None)
ok_(cust_func.called == 3)
def test_subcmd_default_process(self):
def cmd_process(args, sender):
cmd_process.called = True
ok_(args is None)
ok_(sender == 'test_sender')
cmd_process.called = False
LinotArgParser('testcmd', self.parser, cmd_process)
args, unknown_args = self.parser.parse_known_args('testcmd'.split())
args.proc(args, 'test_sender')
def test_direct_command(self):
def cmd_checker1(match_list, cmd, sender):
cmd_checker1.runned = True
cmd_checker1.cmd = cmd
ok_('1234' in match_list)
def cmd_checker2(match_list, cmd, sender):
cmd_checker2.runned = True
cmd_checker2.cmd = cmd
ok_('1234' in match_list)
# Here we only test the api correctness
# the integration test will be in command_server test
ap = LinotArgParser('testcmd', self.parser, None)
ap.add_direct_command(cmd_checker1, '[cxyz]+([0-9]+)', re.IGNORECASE)
ap = LinotArgParser('testcmd2', self.parser, None)
ap.add_direct_command(cmd_checker2, '[abc]+([0-9]+)', re.IGNORECASE)
cmd_checker1.runned = False
cmd_checker2.runned = False
self.parser.process_direct_commands('1234', None)
ok_(cmd_checker1.runned is False)
ok_(cmd_checker2.runned is False)
self.parser.process_direct_commands('xyz1234', None)
ok_(cmd_checker1.runned is True)
ok_(cmd_checker2.runned is False)
cmd_checker1.runned = False
self.parser.process_direct_commands('ab1234', None)
ok_(cmd_checker1.runned is False)
ok_(cmd_checker2.runned is True)
cmd_checker2.runned = False
self.parser.process_direct_commands('c1234', None)
ok_(cmd_checker1.runned is True)
ok_(cmd_checker2.runned is True)
ok_(cmd_checker1.cmd == 'c1234')
ok_(cmd_checker2.cmd == 'c1234')
def test_direct_command(self):
def default_process(args, sender):
ok_(False) # should not reach here
lap = LinotArgParser('testcmd', self.parser, default_process)
def cmd_checker(match_list, cmd, sender):
ok_('somechannel' in match_list)
ok_(len(match_list) == 1)
ok_(cmd == 'www.twitch.tv/somechannel')
cmd_checker.runned = True
lap.add_direct_command(cmd_checker, 'twitch\.tv/(\w+)[\s\t,]*', re.IGNORECASE)
cmd_checker.runned = False
sender = CommandSubmitter('test', 'sender')
fake_cmd = [
(sender, 'www.twitch.tv/somechannel')
]
interfaces.get('test').add_command_list(fake_cmd)
command_server.start(self.parser, ['test'])
threading.Event().wait(.5)
command_server.stop()
ok_(cmd_checker.runned)
def test_print_help(self):
def cmd_process(args, sender):
pass
test_str = 'testtesttest'
lap = LinotArgParser('testcmd', self.parser, cmd_process)
lap.add_argument('-a', action='store_true', help=test_str)
lap.add_argument('-noshow',
action='store_true',
help=argparse.SUPPRESS)
lap.add_argument('-showme', action='store_true', help='')
# test -h and --help goes to print_help
args, unknown_args = self.parser.parse_known_args('testcmd -h'.split())
eq_(len(unknown_args), 0)
sender = CommandSubmitter('test', 'test_sender')
args.proc(args, sender)
msg_queue = interfaces.get('test').msg_queue
ok_('command list' in ' '.join(msg_queue[sender.code]))
args, unknown_args = self.parser.parse_known_args(
'testcmd --help'.split())
eq_(len(unknown_args), 0)
interfaces.get('test').reset()
args.proc(args, sender)
msg_queue = interfaces.get('test').msg_queue
ok_('command list' in ' '.join(msg_queue[sender.code]))
# add help
args, unknown_args = self.parser.parse_known_args('testcmd -h'.split())
interfaces.get('test').reset()
args.proc(args, sender)
msg_queue = interfaces.get('test').msg_queue
msg = ' '.join(msg_queue[sender.code])
ok_(test_str in msg, msg)
ok_('-nowshow' not in msg)
ok_('-showme' in msg)
# Test help suppress if sender not found (for coverage)
args, unknown_args = self.parser.parse_known_args('testcmd -h'.split())
interfaces.get('test').reset()
args.proc(args, None)
msg_queue = interfaces.get('test').msg_queue
msg = ' '.join(msg_queue[sender.code])
ok_(msg is '', msg)
def test_print_help(self):
def cmd_process(args, sender):
pass
test_str = 'testtesttest'
lap = LinotArgParser('testcmd', self.parser, cmd_process)
lap.add_argument('-a', action='store_true', help=test_str)
lap.add_argument('-noshow', action='store_true', help=argparse.SUPPRESS)
lap.add_argument('-showme', action='store_true', help='')
# test -h and --help goes to print_help
args, unknown_args = self.parser.parse_known_args('testcmd -h'.split())
eq_(len(unknown_args), 0)
sender = CommandSubmitter('test', 'test_sender')
args.proc(args, sender)
msg_queue = interfaces.get('test').msg_queue
ok_('command list' in ' '.join(msg_queue[sender.code]))
args, unknown_args = self.parser.parse_known_args('testcmd --help'.split())
eq_(len(unknown_args), 0)
interfaces.get('test').reset()
args.proc(args, sender)
msg_queue = interfaces.get('test').msg_queue
ok_('command list' in ' '.join(msg_queue[sender.code]))
# add help
args, unknown_args = self.parser.parse_known_args('testcmd -h'.split())
interfaces.get('test').reset()
args.proc(args, sender)
msg_queue = interfaces.get('test').msg_queue
msg = ' '.join(msg_queue[sender.code])
ok_(test_str in msg, msg)
ok_('-nowshow' not in msg)
ok_('-showme' in msg)
# Test help suppress if sender not found (for coverage)
args, unknown_args = self.parser.parse_known_args('testcmd -h'.split())
interfaces.get('test').reset()
args.proc(args, None)
msg_queue = interfaces.get('test').msg_queue
msg = ' '.join(msg_queue[sender.code])
ok_(msg is '', msg)
def test_unknown_commands(self):
# test command server can properly handle 1 or multiple commands
def default_process(args, sender):
ok_(getattr(args, sender.code) is True)
default_process.called += 1
lap = LinotArgParser('testcmd', self.parser, default_process)
lap.add_argument('-a', action='store_true')
lap.add_argument('-b', action='store_true')
lap.add_argument('-c', action='store_true')
# Test 1 unknown command, command server respose to user
sender_a = CommandSubmitter('test', 'a')
fake_cmd = [
(sender_a, 'some_unknown_words'),
]
interfaces.get('test').reset()
interfaces.get('test').add_command_list(fake_cmd)
command_server.start(self.parser, ['test'])
default_process.called = 0
threading.Event().wait(.5)
command_server.stop()
ok_(default_process.called == 0)
ok_('Unknown' in ' '.join(interfaces.get('test').msg_queue[sender_a.code]))
# Test multiple unknown commands
sender_a = CommandSubmitter('test', 'a')
sender_u = CommandSubmitter('test', 'u')
fake_cmd = [
(sender_u, 'some_unknown_cmds'),
(sender_a, 'testcmd -a'),
(sender_u, 'some_unknown_cmds'),
]
interfaces.get('test').reset()
interfaces.get('test').add_command_list(fake_cmd)
command_server.start(self.parser, ['test'])
default_process.called = 0
threading.Event().wait(.5)
command_server.stop()
unknown_response = ' '.join(interfaces.get('test').msg_queue[sender_u.code])
ok_(unknown_response.count('Unknown') == 2)
ok_(default_process.called == 1)
def test_cmd_process(self):
# test command server can properly handle 1 or multiple commands
def default_process(args, sender):
ok_(getattr(args, sender.code) is True)
default_process.called += 1
lap = LinotArgParser('testcmd', self.parser, default_process)
lap.add_argument('-a', action='store_true')
lap.add_argument('-b', action='store_true')
lap.add_argument('-c', action='store_true')
# Test 1 cmd return by polling_command
# command = [(sender, cmd string), ...]
sender = CommandSubmitter('test', 'a')
fake_cmd = [(sender, 'testcmd -a')]
interfaces.get('test').add_command_list(fake_cmd)
default_process.called = 0
command_server.start(self.parser, ['test'])
threading.Event().wait(.5)
command_server.stop()
ok_(default_process.called == 1)
# Test 3 cmds return by polling_command
# command = [(sender, cmd string), ...]
sender_a = CommandSubmitter('test', 'a')
sender_b = CommandSubmitter('test', 'b')
sender_c = CommandSubmitter('test', 'c')
fake_cmd = [
(sender_a, 'testcmd -a'),
(sender_b, 'testcmd -b'),
(sender_c, 'testcmd -c'),
]
interfaces.get('test').add_command_list(fake_cmd)
command_server.start(self.parser, ['test'])
default_process.called = 0
threading.Event().wait(.5)
command_server.stop()
ok_(default_process.called == 3)
def test_add_argument_positional(self):
def cmd_process(args, sender):
ok_(False)
lap = LinotArgParser('testcmd', self.parser, cmd_process)
lap.add_argument('abc', action='store_true')
def test_add_argument_dest_exception(self):
def cmd_process(args, sender):
pass
lap = LinotArgParser('testcmd', self.parser, cmd_process)
with assert_raises(ValueError):
lap.add_argument('-a', dest='b', action='store_true')
def test_add_argument_positional(self):
def cmd_process(args, sender):
ok_(False)
lap = LinotArgParser('testcmd', self.parser, cmd_process)
lap.add_argument('abc', action='store_true')
