示例#1
0
class TestCommandManager(unittest.TestCase):
    def setUp(self):
        self.command_manager = CommandManager(Message())

    def test_register_command(self):
        def _test():
            pass

        test_dict = {'blah': _test}
        self.command_manager.register_command('test', test_dict)
        self.assertIn('test', self.command_manager._commands)
        self.assertFalse(self.command_manager.is_command('test'))
        self.assertFalse(self.command_manager.is_command('blah'))
        self.command_manager.register_command('blah', _test)
        self.assertTrue(self.command_manager.is_command('blah'))
        # FIXME: ?
        self.assertTrue(self.command_manager.is_command('test blah'))

    def test_help(self):
        message = vexmessage.Message('target', 'source', 'CMD', command='help')
        self.command_manager.parse_commands(message)
        response_sent = self.command_manager._messaging.response[1]
        self.assertIn('response', response_sent)
        message = vexmessage.Message('target',
                                     'source',
                                     'CMD',
                                     command='help commands')

        self.command_manager.parse_commands(message)
        response_sent = self.command_manager._messaging.response[1]['response']
        self.assertIn('help', response_sent)
        self.assertIn('commands', response_sent)

    def test_help_specific(self):
        message = vexmessage.Message('target',
                                     'source',
                                     'CMD',
                                     command='help',
                                     args=['commands'])

        self.command_manager.parse_commands(message)
        response = self.command_manager._messaging.response
        self.assertIsNotNone(response)

    def test_commands(self):
        message = vexmessage.Message('target',
                                     'source',
                                     'CMD',
                                     command='commands')

        self.command_manager.parse_commands(message)
        response_sent = self.command_manager._messaging.response
        answer = response_sent[1]['response']
        self.assertIn('commands', answer)
        self.assertIn('help', answer)

    def test_is_command_with_call(self):

        def t(*args):
            pass

        self.command_manager.register_command('t', t)
        called = self.command_manager.is_command('t', True)
        self.assertTrue(called)
        not_called = self.command_manager.is_command('f', True)
        self.assertFalse(not_called)
        # FIXME: not sure what actually want here
        called_w_args = self.command_manager.is_command('t these are args',
                                                        True)

        self.assertTrue(called_w_args)

    def test_get_callback_recursively_none(self):
        result = self.command_manager._get_callback_recursively(None)
        self.assertEqual(len(result), 3)
        for r in result:
            self.assertIsNone(r)

    def test_cmd_commands(self):
        def t():
            pass
        self.command_manager.register_command('test', t)
        nested = {'test': t}
        self.command_manager.register_command('nested', nested)
        commands = self.command_manager._cmd_commands(None)
        self.assertIn('test', commands)
        self.assertIn('nested test', commands)
        self.assertNotIn('blah', commands)
        # TODO: test `help` and `commands`?
        self.assertEqual(len(commands), 4)
示例#2
0
class TestCommandManager(unittest.TestCase):
    def setUp(self):
        self.command_manager = CommandManager(Message())

    def test_register_command(self):
        def _test():
            pass

        test_dict = {'blah': _test}
        self.command_manager.register_command('test', test_dict)
        self.assertIn('test', self.command_manager._commands)
        self.assertFalse(self.command_manager.is_command('test'))
        self.assertFalse(self.command_manager.is_command('blah'))
        self.command_manager.register_command('blah', _test)
        self.assertTrue(self.command_manager.is_command('blah'))
        # FIXME: ?
        self.assertTrue(self.command_manager.is_command('test blah'))

    def test_help(self):
        message = vexmessage.Message('target', 'source', 'CMD', command='help')
        self.command_manager.parse_commands(message)
        response_sent = self.command_manager._messaging.response[1]
        self.assertIn('response', response_sent)
        message = vexmessage.Message('target',
                                     'source',
                                     'CMD',
                                     command='help commands')

        self.command_manager.parse_commands(message)
        response_sent = self.command_manager._messaging.response[1]['response']
        self.assertIn('help', response_sent)
        self.assertIn('commands', response_sent)

    def test_help_specific(self):
        message = vexmessage.Message('target',
                                     'source',
                                     'CMD',
                                     command='help',
                                     args=['commands'])

        self.command_manager.parse_commands(message)
        response = self.command_manager._messaging.response
        self.assertIsNotNone(response)

    def test_commands(self):
        message = vexmessage.Message('target',
                                     'source',
                                     'CMD',
                                     command='commands')

        self.command_manager.parse_commands(message)
        response_sent = self.command_manager._messaging.response
        answer = response_sent[1]['response']
        self.assertIn('commands', answer)
        self.assertIn('help', answer)

    def test_is_command_with_call(self):
        def t(*args):
            pass

        self.command_manager.register_command('t', t)
        called = self.command_manager.is_command('t', True)
        self.assertTrue(called)
        not_called = self.command_manager.is_command('f', True)
        self.assertFalse(not_called)
        # FIXME: not sure what actually want here
        called_w_args = self.command_manager.is_command(
            't these are args', True)

        self.assertTrue(called_w_args)

    def test_get_callback_recursively_none(self):
        result = self.command_manager._get_callback_recursively(None)
        self.assertEqual(len(result), 3)
        for r in result:
            self.assertIsNone(r)

    def test_cmd_commands(self):
        def t():
            pass

        self.command_manager.register_command('test', t)
        nested = {'test': t}
        self.command_manager.register_command('nested', nested)
        commands = self.command_manager._cmd_commands(None)
        self.assertIn('test', commands)
        self.assertIn('nested test', commands)
        self.assertNotIn('blah', commands)
        # TODO: test `help` and `commands`?
        self.assertEqual(len(commands), 4)
示例#3
0
class Shell(cmd.Cmd):
    def __init__(self,
                 context=None,
                 prompt_name='vexbot',
                 publish_address=None,
                 subscribe_address=None,
                 **kwargs):

        super().__init__()
        self.messaging = ZmqMessaging('shell', publish_address,
                                      subscribe_address, 'shell')

        self.command_manager = CommandManager(self.messaging)
        # FIXME
        self.command_manager._commands.pop('commands')
        self.stdout.write('Vexbot {}\n'.format(__version__))
        if kwargs.get('already_running', False):
            self.stdout.write('vexbot already running\n')
        self.stdout.write("Type \"help\" for command line help or "
                          "\"commands\" for bot commands\n\n")

        self.command_manager.register_command('start_vexbot', _start_vexbot)

        self.messaging.start_messaging()

        self.prompt = prompt_name + ': '
        self.misc_header = "Commands"
        self._exit_loop = False
        self._set_readline_helper(kwargs.get('history_file'))

    def default(self, arg):
        if not self.command_manager.is_command(arg, call_command=True):
            command, argument, line = self.parseline(arg)

            self.messaging.send_command(command=command,
                                        args=argument,
                                        line=line)

    def _set_readline_helper(self, history_file=None):
        try:
            import readline
        except ImportError:
            return

        try:
            readline.read_history_file(history_file)
        except IOError:
            pass
        readline.set_history_length(1000)
        atexit.register(readline.write_history_file, history_file)

    def run(self):
        frame = None
        while True and not self._exit_loop:
            try:
                # NOTE: not blocking here to check the _exit_loop condition
                frame = self.messaging.sub_socket.recv_multipart(zmq.NOBLOCK)
            except zmq.error.ZMQError:
                pass

            sleep(.5)

            if frame:
                message = decode_vex_message(frame)
                if message.type == 'RSP':
                    self.stdout.write("\n{}\n".format(self.doc_leader))
                    header = message.contents.get('original', 'Response')
                    contents = message.contents.get('response', None)
                    # FIXME
                    if (isinstance(header, (tuple, list))
                            and isinstance(contents,
                                           (tuple, list)) and contents):

                        for head, content in zip(header, contents):
                            self.print_topics(head, (contents, ), 15, 70)
                    else:
                        if isinstance(contents, str):
                            contents = (contents, )
                        self.print_topics(header, contents, 15, 70)

                    self.stdout.write("vexbot: ")
                    self.stdout.flush()

                else:
                    # FIXME
                    print(message.type, message.contents,
                          'fix me in shell adapter, run function')
                frame = None

    def _create_command_function(self, command):
        def resulting_function(arg):
            self.default(' '.join((command, arg)))

        return resulting_function

    def do_EOF(self, arg):
        self.stdout.write('\n')
        # NOTE: This ensures we exit out of the `run` method on EOF
        self._exit_loop = True
        return True

    def get_names(self):
        return dir(self)

    def do_help(self, arg):
        if arg:
            if self.command_manager.is_command(arg):
                doc = self.command_manager._commands[arg].__doc__
                if doc:
                    self.stdout.write("{}\n".format(str(doc)))
            else:
                self.messaging.send_command(command='help', args=arg)

        else:
            self.stdout.write("{}\n".format(self.doc_leader))
            # TODO: get these from robot?
            self.print_topics(self.misc_header, [
                'start vexbot\nhelp [foo]',
            ], 15, 80)

    def add_completion(self, command):
        setattr(self, 'do_{}'.format(command),
                self._create_command_function(command))

    """
示例#4
0
文件: shell.py 项目: benhoff/vexbot
class Shell(cmd.Cmd):
    def __init__(self,
                 context=None,
                 prompt_name='vexbot',
                 publish_address=None,
                 subscribe_address=None,
                 **kwargs):

        super().__init__()
        self.messaging = ZmqMessaging('shell',
                                      publish_address,
                                      subscribe_address,
                                      'shell')

        self.command_manager = CommandManager(self.messaging)
        # FIXME
        self.command_manager._commands.pop('commands')
        self.stdout.write('Vexbot {}\n'.format(__version__))
        if kwargs.get('already_running', False):
            self.stdout.write('vexbot already running\n')
        self.stdout.write("Type \"help\" for command line help or "
                          "\"commands\" for bot commands\n\n")

        self.command_manager.register_command('start_vexbot',
                                              _start_vexbot)

        self.messaging.start_messaging()

        self.prompt = prompt_name + ': '
        self.misc_header = "Commands"
        self._exit_loop = False
        self._set_readline_helper(kwargs.get('history_file'))

    def default(self, arg):
        if not self.command_manager.is_command(arg, call_command=True):
            command, argument, line = self.parseline(arg)

            self.messaging.send_command(command=command,
                                        args=argument,
                                        line=line)

    def _set_readline_helper(self, history_file=None):
        try:
            import readline
        except ImportError:
            return

        try:
            readline.read_history_file(history_file)
        except IOError:
            pass
        readline.set_history_length(1000)
        atexit.register(readline.write_history_file, history_file)

    def run(self):
        frame = None
        while True and not self._exit_loop:
            try:
                # NOTE: not blocking here to check the _exit_loop condition
                frame = self.messaging.sub_socket.recv_multipart(zmq.NOBLOCK)
            except zmq.error.ZMQError:
                pass

            sleep(.5)

            if frame:
                message = decode_vex_message(frame)
                if message.type == 'RSP':
                    self.stdout.write("\n{}\n".format(self.doc_leader))
                    header = message.contents.get('original', 'Response')
                    contents = message.contents.get('response', None)
                    # FIXME
                    if (isinstance(header, (tuple, list))
                            and isinstance(contents, (tuple, list))
                            and contents):

                        for head, content in zip(header, contents):
                            self.print_topics(head, (contents,), 15, 70)
                    else:
                        if isinstance(contents, str):
                            contents = (contents,)
                        self.print_topics(header,
                                          contents,
                                          15,
                                          70)

                    self.stdout.write("vexbot: ")
                    self.stdout.flush()

                else:
                    # FIXME
                    print(message.type,
                          message.contents,
                          'fix me in shell adapter, run function')
                frame = None

    def _create_command_function(self, command):
        def resulting_function(arg):
            self.default(' '.join((command, arg)))
        return resulting_function

    def do_EOF(self, arg):
        self.stdout.write('\n')
        # NOTE: This ensures we exit out of the `run` method on EOF
        self._exit_loop = True
        return True

    def get_names(self):
        return dir(self)

    def do_help(self, arg):
        if arg:
            if self.command_manager.is_command(arg):
                doc = self.command_manager._commands[arg].__doc__
                if doc:
                    self.stdout.write("{}\n".format(str(doc)))
            else:
                self.messaging.send_command(command='help', args=arg)

        else:
            self.stdout.write("{}\n".format(self.doc_leader))
            # TODO: get these from robot?
            self.print_topics(self.misc_header,
                              ['start vexbot\nhelp [foo]', ],
                              15,
                              80)

    def add_completion(self, command):
        setattr(self,
                'do_{}'.format(command),
                self._create_command_function(command))

    """