Exemplo n.º 1
0
 def test_match(self):
     f = mocks.FE()
     w = messager.Messager(f)
     self.assertFalse(w.match('foo'))
     f.context.backends._messages[0]._display = chunks.Chunk([((), 'foo\n')
                                                              ])
     self.assertTrue(w.match('foo'))
Exemplo n.º 2
0
 def test_quit_hook_starks(self):
     f = mocks.FE()
     w = messager.Messager(f)
     self.assertIsNotNone(w.replymsg())
     self.assertFalse(f.context.starks)
     w.quit_hook()
     self.assertTrue(f.context.starks)
Exemplo n.º 3
0
 def test_move_backwards_target(self):
     f = mocks.FE()
     w = messager.Messager(f)
     w.move(-1)
     self.assertIsNotNone(f.context.backends._target)
     self.assertLess(f.context.backends._target, 0)
     self.assertTrue(math.isinf(f.context.backends._target))
Exemplo n.º 4
0
    def test_modeline(self):
        f = mocks.FE()
        w = messager.Messager(f)
        w.renderer = mocks.Renderer()
        self.assertEqual(w.modeline(),
                         ([(set(), 'filter default')], [({'right'}, '1')]))
        m = f.context.backends._messages[0]
        m.time = 0.0
        w.renderer = mocks.Renderer((m, m))
        os.environ['TZ'] = 'GMT'
        self.assertEqual(w.modeline(),
                         ([({'dim'}, '1970-01-01 00:00'),
                           (set(), ' filter default')], [({'right'}, '1')]))
        m.time = float('NaN')

        class mockdatetime(datetime.datetime):
            @staticmethod
            def now():
                return datetime.datetime.fromtimestamp(60)

        with patch('datetime.datetime', mockdatetime):
            self.assertEqual(
                w.modeline(),
                ([({'dim'}, '00:01'),
                  (set(), ' filter default')], [({'right'}, '1')]))
Exemplo n.º 5
0
    def test_mark(self):
        f = mocks.FE()
        w = messager.Messager(f)
        self.assertIsNone(w.the_mark)
        m = f.context.backends._messages
        m.append(mocks.Message())
        m.append(mocks.Message())
        w.set_mark()
        self.assertEqual(w.the_mark, w.cursor)
        w.set_mark(m[-1])
        self.assertEqual(w.the_mark, m[-1])
        self.assertEqual(w.mark_ring[-1], m[0])

        where = w.cursor
        there = w.the_mark
        anywhere = w.mark_ring[-1]
        w.set_mark(prefix=[4])
        self.assertEqual(w.mark_ring[0], where)
        self.assertEqual(w.the_mark, anywhere)
        self.assertEqual(w.cursor, there)

        o = object()
        self.assertIs(o, w.make_mark(o))  # pass through

        self.assertNotEqual(w.cursor, m[0])
        w.go_mark(m[0])
        self.assertEqual(w.cursor, m[0])
        w.the_mark = m[-1]
        w.exchange_point_and_mark()
        self.assertEqual(w.cursor, m[-1])
        self.assertEqual(w.the_mark, m[0])
Exemplo n.º 6
0
 def test_view_bad_message(self):
     f = mocks.FE()
     w = messager.Messager(f)
     f.context.backends._messages[0]._display = [()]  # malformed chunk
     self.assertEqual(
         ({'visible', 'bar'}, '[()]\n'),
         [chunk.tagsets() for (mark, chunk) in w.view(0)][0][0])
Exemplo n.º 7
0
    def test_keyseqprompt(self):
        result = None

        def cb(s):
            nonlocal result
            result = s

        w = prompt.KeySeqPrompt(mocks.FE(),
                                prompt=': ',
                                keymap=keymap.Keymap({'a': 0}),
                                callback=cb)

        w.keyecho('a')  # how do you test that somethign did nothing?

        w.echo_keystroke('a')
        self.assertEqual(w.keystrokes, ['a'])
        self.assertEqual(w.input(), 'a ')

        w.runcallback()
        self.assertEqual(result, (['a'], None))
        self.assertEqual([(0, [
            ({'bold'}, ': '),
            ((), 'a '),
            ({'cursor', 'visible'}, ''),
        ])], [(int(mark), chunk.tagsets()) for (mark, chunk) in w.view(0)])
Exemplo n.º 8
0
 def test_yank(self):
     e = snipe.editor.Editor(None)
     e.fe = mocks.FE()
     e.insert_region('foo')
     self.assertEqual('foo', str(e.buf))
     e.kill_region()
     self.assertEqual('', str(e.buf))
     e.yank()
     self.assertEqual('foo', str(e.buf))
     e.kill_region()
     self.assertEqual('', str(e.buf))
     e.insert_region('bar')
     self.assertEqual('bar', str(e.buf))
     e.kill_region()
     self.assertEqual('', str(e.buf))
     e.yank(2)
     self.assertEqual('foo', str(e.buf))
     self.assertEqual(3, e.cursor)
     self.assertEqual(0, e.the_mark)
     e.kill_region()
     e.yank([])
     self.assertEqual('foo', str(e.buf))
     self.assertEqual(0, e.cursor)
     self.assertEqual(3, e.the_mark)
     e.kill_region()
     e.yank()
     self.assertEqual('foo', str(e.buf))
     e.whine = Mock()
     e.yank_pop()
     e.whine.assert_called()
     e.last_command = 'yank'
     e.yank_pop(2)
     self.assertEqual('bar', str(e.buf))
Exemplo n.º 9
0
 def test_focus(self):
     w = messager.Messager(mocks.FE())
     c = w.cursor
     w.secondary, w.cursor = c, None
     self.assertTrue(w.focus())
     self.assertIs(w.cursor, c)
     self.assertIsNone(w.secondary)
Exemplo n.º 10
0
    async def test_send(self):
        f = mocks.FE()
        m = mocks.Message()
        m.omega = True
        f.context.backends._messages.append(m)
        w = messager.Messager(f)
        w.renderer = mocks.Renderer((f.context.backends._messages[0],
                                     f.context.backends._messages[-1]))

        c = w.cursor

        _read_args = None
        _read_kw = None
        _read_result = 'foo\nbar'

        async def read_string(*args, **kw):
            nonlocal _read_args, _read_kw
            _read_args, _read_kw = args, kw
            return _read_result

        w.read_string = read_string
        await w.send()

        self.assertEqual(f.context.backends._sent[-1], ('foo', 'bar'))
        self.assertNotIn('modes', _read_kw)
        self.assertEqual(w.secondary, c)

        w.cursor = c
        _read_result = 'foo'

        await w.send(msg=c)

        self.assertIn('modes', _read_kw)
        self.assertEqual(f.context.backends._sent[-1], ('foo', ''))
Exemplo n.º 11
0
    def test_go(self):
        w = repl.REPL(mocks.FE())
        w.log.debug('A: %s', repr(w.buf[:]))
        w.insert('2 + 2')
        w.log.debug('B: %s', repr(w.buf[:]))
        earlier = w.cursor.point
        w.go()
        w.log.debug('C: %s', repr(w.buf[:]))
        result = '\n' + str(4) + '\n' + w.state['ps1']
        self.assertEqual(w.buf[-len(result):], result)
        self.assertEqual(w.state['in'][0], '2 + 2')
        self.assertEqual(w.state['out'][0], 4)

        t = 'def flurb():'
        w.insert(t)
        w.log.debug('D: %s', repr(w.buf[:]))
        w.go()
        self.assertEqual(w.context._message, 'incomplete input')
        w.log.debug('E before go2: %s', repr(w.buf[:]))
        w.go2()
        w.log.debug('F after go2: %s', repr(w.buf[:]))
        self.assertEqual(w.buf[-(len(t) + 1):], t + '\n')

        w.cursor.point = earlier
        w.go()
        result = result + t + '\n'
        self.assertEqual(w.buf[-len(result):], result)
        self.assertEqual(w.state['in'][1], '2 + 2')
        self.assertEqual(w.state['out'][1], 4)
Exemplo n.º 12
0
 def test_pageup_backfill(self):
     f = mocks.FE()
     w = messager.Messager(f)
     w.renderer = mocks.Renderer(range=tuple(f.context.backends._messages *
                                             2))
     self.assertIsNone(f.context.backends._target)
     w.pageup()
     self.assertTrue(math.isinf(f.context.backends._target))
Exemplo n.º 13
0
    async def test_filter_sender(self):
        f = mocks.FE()
        w = messager.Messager(f)
        w.read_string = returning('green')

        await w.filter_sender()

        self.assertEqual(str(w.filter), 'filter default and sender = "green"')
Exemplo n.º 14
0
 def test_evaller_2(self):
     e = snipe.editor.Editor(None)
     e.fe = mocks.FE()
     e.set_mark()
     e.insert('if True:\n')
     self.assertEqual('if True:\n', str(e.buf))
     e.eval_region(arg=['x'])
     self.assertIn('notify', e.fe.called)
     self.assertEqual('if True:\n', str(e.buf))
Exemplo n.º 15
0
 def test_cursor_set_walk(self):
     f = mocks.FE()
     w = messager.Messager(f)
     m = mocks.Message()
     m.omega = True
     f.context.backends._messages.append(m)
     self.assertEqual(w.cursor, f.context.backends._messages[0])
     w.cursor_set_walk_mark(None, False)
     self.assertEqual(w.cursor, f.context.backends._messages[1])
Exemplo n.º 16
0
 def test_move_cleverness_arg(self):
     f = mocks.FE()
     w = messager.Messager(f)
     w.move_cleverly(True, None)
     self.assertEqual(w.move_cleverly_state, 0)
     w.move_cleverly(True, 1)
     self.assertEqual(w.move_cleverly_state, 1)
     w.move_cleverly(True, 'xx')
     self.assertEqual(w.move_cleverly_state, 2)
Exemplo n.º 17
0
 def test_redisplay(self):
     s = SyntheticBackend(mocks.Context())
     s.context.ui = mocks.FE()
     self.assertNotIn('redisplay', s.context.ui.called)
     s.redisplay(None, None)
     self.assertIn('redisplay', s.context.ui.called)
     s.context.ui.redisplay = lambda: None
     with self.assertLogs(s.log.name, level='ERROR'):
         s.redisplay(None, None)
Exemplo n.º 18
0
 def test_filter_clear_decorate(self):
     f = mocks.FE()
     w = messager.Messager(f)
     w.filter = filters.Yes()
     decor = {'foreground': 'white', 'background': 'blue'}
     w.filter_clear_decorate(decor)
     self.assertEqual(f.context.conf['rule'], [('yes', decor)])
     self.assertEqual([[({'visible', 'bar'}, '\n')]],
                      [chunk.tagsets() for (mark, chunk) in w.view(0)])
Exemplo n.º 19
0
    def test_next_prev_day(self):
        f = mocks.FE()
        w = messager.Messager(f)

        target = None

        def mock_goto_time(*args):
            nonlocal target
            target = args

        w.goto_time = mock_goto_time

        class MockDate:
            TODAY = datetime.date(1970, 1, 1)

            @classmethod
            def today(klass, *args):
                return klass.TODAY

        f.context.backends._messages[0].omega = True
        os.environ['TZ'] = 'GMT'
        try:
            # pypy
            with patch('datetime.date.today', MockDate.today):
                w.prev_day()
        except TypeError:
            # cpython
            with patch('datetime.date', MockDate):
                w.prev_day()
        self.assertEqual(target, (0.0, ))

        f.context.backends._messages[0].omega = False
        f.context.backends._messages[0].time = \
            datetime.datetime(1970, 1, 2).timestamp()
        target = None
        w.prev_day()
        self.assertEqual(target, (0.0, ))

        target = None
        w.next_day(-1)
        self.assertEqual(target, (0.0, ))

        target = None
        f.context.backends._messages[0].omega = True
        w.next_day()
        self.assertIsNone(target)

        f.context.backends._messages[0].omega = False
        f.context.backends._messages[0].time = \
            datetime.datetime(1969, 12, 31).timestamp()
        w.next_day()
        self.assertEqual(target, (0.0, ))

        target = None
        w.prev_day(-1)
        self.assertEqual(target, (0.0, ))
Exemplo n.º 20
0
    async def test_filter_class(self):
        f = mocks.FE()
        w = messager.Messager(f)
        w.read_string = returning('green')

        await w.filter_class()

        self.assertEqual(
            str(w.filter),
            'filter default and backend == "roost" and class = "green"')
Exemplo n.º 21
0
 def test_after_command(self):
     f = mocks.FE()
     w = messager.Messager(f)
     m = mocks.Message()
     m.omega = True
     f.context.backends._messages.append(m)
     w.next_message()
     w.after_command()
     self.assertEqual(f.context.starks[-1],
                      f.context.backends._messages[0].time)
Exemplo n.º 22
0
    def test_move_cleverly(self):
        f = mocks.FE()
        w = messager.Messager(f)
        f.context.backends._messages.append(mocks.Message())

        self.assertIs(w.cursor, f.context.backends._messages[0])
        w.next_message_cleverly()
        self.assertIs(w.cursor, f.context.backends._messages[1])
        w.prev_message_cleverly()
        self.assertIs(w.cursor, f.context.backends._messages[0])
Exemplo n.º 23
0
    def test_set_stark(self):
        w = messager.Messager(mocks.FE())
        m = w.context.backends._messages

        self.assertFalse(w.context.starks)
        m[0].omega = True
        w.set_stark()
        self.assertFalse(w.context.starks)
        m[0].omega = False
        w.set_stark()
        self.assertEqual(w.context.starks, [m[0].time])
Exemplo n.º 24
0
 def test(self):
     fe = mocks.FE()
     v = snipe.editor.PopViewer(fe, content='', name='test')
     v.renderer = mocks.Renderer()
     v.renderer._range = [0, 0]
     self.assertEqual(
         (([(set(), '- test')]), ([({'right'}, '1')])), v.modeline())
     name = v.buf.name
     self.assertIn(name, v.buf.registry)
     v.destroy()
     self.assertNotIn(name, v.buf.registry)
Exemplo n.º 25
0
    def test_list_destinations(self):
        w = messager.Messager(mocks.FE())
        out = None

        def mock_show(text):
            nonlocal out
            out = text

        w.show = mock_show
        w.list_destinations()
        self.assertEqual(out, '')
Exemplo n.º 26
0
 def test_end_beginning(self):
     f = mocks.FE()
     w = messager.Messager(f)
     m = mocks.Message()
     m.omega = True
     f.context.backends._messages.append(m)
     self.assertEqual(w.cursor, f.context.backends._messages[0])
     w.end()
     self.assertEqual(w.cursor, f.context.backends._messages[1])
     w.beginning()
     self.assertEqual(w.cursor, f.context.backends._messages[0])
Exemplo n.º 27
0
 def test_check_redisplay_hint(self):
     f = mocks.FE()
     w = messager.Messager(f)
     w.renderer = mocks.Renderer()
     self.assertFalse(w.check_redisplay_hint({}))
     hint = w.redisplay_hint()
     self.assertTrue(w.check_redisplay_hint(hint))
     r = (f.context.backends._messages[0], f.context.backends._messages[-1])
     self.assertFalse(w.check_redisplay_hint({'messages': r}))
     w.filter = filters.Yes()
     w.renderer = mocks.Renderer(range=r)
     self.assertTrue(w.check_redisplay_hint({'messages': r}))
Exemplo n.º 28
0
    def test_replace_cursor(self):
        w = prompt.Search(mocks.FE(),
                          forward=False,
                          prompt='search ',
                          history='test_search',
                          target=mocks.Window([]))

        w.insert('fo')
        mark = w.make_mark(w.cursor)
        w.target.find_ret = False
        w.insert('o')
        self.assertEqual(w.cursor.point, mark.point + 1)
Exemplo n.º 29
0
 def test_view_search(self):
     f = mocks.FE()
     w = messager.Messager(f)
     f.context.backends._messages[0]._display = chunks.Chunk([
         ((), 'bar\nfoo\n')
     ])
     w.search_re = re.compile('foo')
     self.assertEqual([
         ({'visible', 'bar'}, 'bar\n'),
         ({'reverse'}, 'foo'),
         ((), '\n'),
     ], [chunk.tagsets() for (mark, chunk) in w.view(0)][0])
Exemplo n.º 30
0
 def test_filter_push(self):
     f = mocks.FE()
     w = messager.Messager(f)
     w.filter = None
     f0 = filters.Yes()
     w.filter_push(f0)
     self.assertIs(w.filter, f0)
     self.assertEqual(w.filter_stack, [])
     f1 = filters.No()
     w.filter_push(f1)
     self.assertEqual(w.filter, filters.And(f0, f1))
     self.assertEqual(w.filter_stack, [f0])