import collections

from itertools import islice

import os

import socket

import sys

import unittest

from mock import Mock, MagicMock

try:

from unittest import skip

except ImportError:

def skip(f):

return lambda self: None

py3 = (sys.version_info[0] == 3)

from bpython import config, repl, cli, autocomplete

def setup_config(conf):

config_struct = config.Struct()

config.loadini(config_struct, os.devnull)

if 'autocomplete_mode' in conf:

config_struct.autocomplete_mode = conf['autocomplete_mode']

return config_struct

class FakeHistory(repl.History):

def __init__(self):

pass

def reset(self):

pass

class FakeRepl(repl.Repl):

def __init__(self, conf={}):

repl.Repl.__init__(self, repl.Interpreter(), setup_config(conf))

self.current_line = ""

self.cursor_offset = 0

class FakeCliRepl(cli.CLIRepl, FakeRepl):

def __init__(self):

self.s = ''

self.cpos = 0

self.rl_history = FakeHistory()

class TestHistory(unittest.TestCase):

def setUp(self):

self.history = repl.History('#%d' % x for x in range(1000))

def test_is_at_start(self):

self.history.first()

self.assertNotEqual(self.history.index, 0)

self.assertTrue(self.history.is_at_end)

self.history.forward()

self.assertFalse(self.history.is_at_end)

def test_is_at_end(self):

self.history.last()

self.assertEqual(self.history.index, 0)

self.assertTrue(self.history.is_at_start)

self.assertFalse(self.history.is_at_end)

def test_first(self):

self.history.first()

self.assertFalse(self.history.is_at_start)

self.assertTrue(self.history.is_at_end)

def test_last(self):

self.history.last()

self.assertTrue(self.history.is_at_start)

self.assertFalse(self.history.is_at_end)

def test_back(self):

self.assertEqual(self.history.back(), '#999')

self.assertNotEqual(self.history.back(), '#999')

self.assertEqual(self.history.back(), '#997')

for x in range(997):

self.history.back()

self.assertEqual(self.history.back(), '#0')

def test_forward(self):

self.history.first()

self.assertEqual(self.history.forward(), '#1')

self.assertNotEqual(self.history.forward(), '#1')

self.assertEqual(self.history.forward(), '#3')

# 1000 == entries 4 == len(range(1, 3) ===> '#1000' (so +1)

for x in range(1000 - 4 - 1):

self.history.forward()

self.assertEqual(self.history.forward(), '#999')

def test_append(self):

self.history.append('print "foo\n"\n')

self.history.append('\n')

self.assertEqual(self.history.back(), 'print "foo\n"')

@skip("I don't understand this test")

def test_enter(self):

self.history.enter('#lastnumber!')

self.assertEqual(self.history.back(), '#999')

self.assertEqual(self.history.forward(), '#lastnumber!')

def test_reset(self):

self.history.enter('#lastnumber!')

self.history.reset()

self.assertEqual(self.history.back(), '#999')

self.assertEqual(self.history.forward(), '')

class TestMatchesIterator(unittest.TestCase):

def setUp(self):

self.matches = ['bobby', 'bobbies', 'bobberina']

self.matches_iterator = repl.MatchesIterator()

self.matches_iterator.current_word = 'bob'

self.matches_iterator.orig_line = 'bob'

self.matches_iterator.orig_cursor_offset = len('bob')

self.matches_iterator.matches = self.matches

def test_next(self):

self.assertEqual(self.matches_iterator.next(), self.matches[0])

for x in range(len(self.matches) - 1):

self.matches_iterator.next()

self.assertEqual(self.matches_iterator.next(), self.matches[0])

self.assertEqual(self.matches_iterator.next(), self. matches[1])

self.assertNotEqual(self.matches_iterator.next(), self.matches[1])

def test_previous(self):

self.assertEqual(self.matches_iterator.previous(), self.matches[2])

for x in range(len(self.matches) - 1):

self.matches_iterator.previous()

self.assertNotEqual(self.matches_iterator.previous(), self.matches[0])

self.assertEqual(self.matches_iterator.previous(), self.matches[1])

self.assertEqual(self.matches_iterator.previous(), self.matches[0])

def test_nonzero(self):

"""self.matches_iterator should be False at start,

then True once we active a match.

"""

self.assertFalse(self.matches_iterator)

self.matches_iterator.next()

self.assertTrue(self.matches_iterator)

def test_iter(self):

slice = islice(self.matches_iterator, 0, 9)

self.assertEqual(list(slice), self.matches * 3)

def test_current(self):

self.assertRaises(ValueError, self.matches_iterator.current)

self.matches_iterator.next()

self.assertEqual(self.matches_iterator.current(), self.matches[0])

def test_update(self):

slice = islice(self.matches_iterator, 0, 3)

self.assertEqual(list(slice), self.matches)

newmatches = ['string', 'str', 'set']

completer = Mock()

completer.locate.return_value = (0, 1, 's')

self.matches_iterator.update(1, 's', newmatches, completer)

newslice = islice(newmatches, 0, 3)

self.assertNotEqual(list(slice), self.matches)

self.assertEqual(list(newslice), newmatches)

def test_cur_line(self):

completer = Mock()

completer.locate.return_value = (0,

self.matches_iterator.orig_cursor_offset,

self.matches_iterator.orig_line)

self.matches_iterator.completer = completer

self.assertRaises(ValueError, self.matches_iterator.cur_line)

self.assertEqual(self.matches_iterator.next(), self.matches[0])

self.assertEqual(self.matches_iterator.cur_line(),

(len(self.matches[0]), self.matches[0]))

def test_is_cseq(self):

self.assertTrue(self.matches_iterator.is_cseq())

class TestArgspec(unittest.TestCase):

def setUp(self):

self.repl = FakeRepl()

self.repl.push("def spam(a, b, c):\n", False)

self.repl.push(" pass\n", False)

self.repl.push("\n", False)

def setInputLine(self, line):

"""Set current input line of the test REPL."""

self.repl.current_line = line

self.repl.cursor_offset = len(line)

def test_func_name(self):

for (line, expected_name) in [("spam(", "spam"),

("spam(map([]", "map"),

("spam((), ", "spam")]:

self.setInputLine(line)

self.assertTrue(self.repl.get_args())

self.assertEqual(self.repl.current_func.__name__, expected_name)

def test_syntax_error_parens(self):

for line in ["spam(]", "spam([)", "spam())"]:

self.setInputLine(line)

# Should not explode

self.repl.get_args()

def test_kw_arg_position(self):

self.setInputLine("spam(a=0")

self.assertTrue(self.repl.get_args())

self.assertEqual(self.repl.argspec[3], "a")

self.setInputLine("spam(1, b=1")

self.assertTrue(self.repl.get_args())

self.assertEqual(self.repl.argspec[3], "b")

self.setInputLine("spam(1, c=2")

self.assertTrue(self.repl.get_args())

self.assertEqual(self.repl.argspec[3], "c")

def test_lambda_position(self):

self.setInputLine("spam(lambda a, b: 1, ")

self.assertTrue(self.repl.get_args())

self.assertTrue(self.repl.argspec)

# Argument position

self.assertEqual(self.repl.argspec[3], 1)

def test_issue127(self):

self.setInputLine("x=range(")

self.assertTrue(self.repl.get_args())

self.assertEqual(self.repl.current_func.__name__, "range")

self.setInputLine("{x:range(")

self.assertTrue(self.repl.get_args())

self.assertEqual(self.repl.current_func.__name__, "range")

self.setInputLine("foo(1, 2, x,range(")

self.assertEqual(self.repl.current_func.__name__, "range")

self.setInputLine("(x,range(")

self.assertEqual(self.repl.current_func.__name__, "range")

def test_nonexistent_name(self):

self.setInputLine("spamspamspam(")

self.assertFalse(self.repl.get_args())

class TestGetSource(unittest.TestCase):

def setUp(self):

self.repl = FakeRepl()

def set_input_line(self, line):

"""Set current input line of the test REPL."""

self.repl.current_line = line

self.repl.cursor_offset = len(line)

def assert_get_source_error_for_current_function(self, func, msg):

self.repl.current_func = func

self.assertRaises(repl.SourceNotFound, self.repl.get_source_of_current_name)

try:

self.repl.get_source_of_current_name()

except repl.SourceNotFound as e:

self.assertEqual(e.args[0], msg)

def test_current_function(self):

self.set_input_line('INPUTLINE')

self.repl.current_func = collections.MutableSet.add

self.assertTrue("Add an element." in self.repl.get_source_of_current_name())

self.assert_get_source_error_for_current_function(

collections.defaultdict.copy, "No source code found for INPUTLINE")

self.assert_get_source_error_for_current_function(

collections.defaultdict, "could not find class definition")

self.assert_get_source_error_for_current_function(

[], "No source code found for INPUTLINE")

self.assert_get_source_error_for_current_function(

list.pop, "No source code found for INPUTLINE")

def test_current_line(self):

self.repl.interp.locals['a'] = socket.socket

self.set_input_line('a')

self.assertTrue('dup(self)' in self.repl.get_source_of_current_name())

#TODO add tests for various failures without using current function

class TestRepl(unittest.TestCase):

def setInputLine(self, line):

"""Set current input line of the test REPL."""

self.repl.current_line = line

self.repl.cursor_offset = len(line)

def setUp(self):

self.repl = FakeRepl()

def test_current_string(self):

self.setInputLine('a = "2"')

self.repl.cpos = 0 #TODO factor cpos out of repl.Repl

self.assertEqual(self.repl.current_string(), '"2"')

self.setInputLine('a = "2" + 2')

self.assertEqual(self.repl.current_string(), '')

def test_push(self):

self.repl = FakeRepl()

self.repl.push("foobar = 2")

self.assertEqual(self.repl.interp.locals['foobar'], 2)

# COMPLETE TESTS

# 1. Global tests

def test_simple_global_complete(self):

self.repl = FakeRepl({'autocomplete_mode': autocomplete.SIMPLE})

self.setInputLine("d")

self.assertTrue(self.repl.complete())

self.assertTrue(hasattr(self.repl.matches_iter, 'matches'))

self.assertEqual(self.repl.matches_iter.matches,

['def', 'del', 'delattr(', 'dict(', 'dir(', 'divmod('])

@skip("disabled while non-simple completion is disabled")

def test_substring_global_complete(self):

self.repl = FakeRepl({'autocomplete_mode': autocomplete.SUBSTRING})

self.setInputLine("time")

self.assertTrue(self.repl.complete())

self.assertTrue(hasattr(self.repl.completer,'matches'))

self.assertEqual(self.repl.completer.matches,

['RuntimeError(', 'RuntimeWarning('])

@skip("disabled while non-simple completion is disabled")

def test_fuzzy_global_complete(self):

self.repl = FakeRepl({'autocomplete_mode': autocomplete.FUZZY})

self.setInputLine("doc")

self.assertTrue(self.repl.complete())

self.assertTrue(hasattr(self.repl.completer,'matches'))

self.assertEqual(self.repl.completer.matches,

['UnboundLocalError(', '__doc__'])

# 2. Attribute tests

def test_simple_attribute_complete(self):

self.repl = FakeRepl({'autocomplete_mode': autocomplete.SIMPLE})

self.setInputLine("Foo.b")

code = "class Foo():\n\tdef bar(self):\n\t\tpass\n"

for line in code.split("\n"):

self.repl.push(line)

self.assertTrue(self.repl.complete())

self.assertTrue(hasattr(self.repl.matches_iter,'matches'))

self.assertEqual(self.repl.matches_iter.matches,

['Foo.bar'])

@skip("disabled while non-simple completion is disabled")

def test_substring_attribute_complete(self):

self.repl = FakeRepl({'autocomplete_mode': autocomplete.SUBSTRING})

self.setInputLine("Foo.az")

code = "class Foo():\n\tdef baz(self):\n\t\tpass\n"

for line in code.split("\n"):

self.repl.push(line)

self.assertTrue(self.repl.complete())

self.assertTrue(hasattr(self.repl.completer,'matches'))

self.assertEqual(self.repl.completer.matches,

['Foo.baz'])

@skip("disabled while non-simple completion is disabled")

def test_fuzzy_attribute_complete(self):

self.repl = FakeRepl({'autocomplete_mode': autocomplete.FUZZY})

self.setInputLine("Foo.br")

code = "class Foo():\n\tdef bar(self):\n\t\tpass\n"

for line in code.split("\n"):

self.repl.push(line)

self.assertTrue(self.repl.complete())

self.assertTrue(hasattr(self.repl.completer,'matches'))

self.assertEqual(self.repl.completer.matches,

['Foo.bar'])

# 3. Edge Cases

def test_updating_namespace_complete(self):

self.repl = FakeRepl({'autocomplete_mode': autocomplete.SIMPLE})

self.setInputLine("foo")

self.repl.push("foobar = 2")

self.assertTrue(self.repl.complete())

self.assertTrue(hasattr(self.repl.matches_iter,'matches'))

self.assertEqual(self.repl.matches_iter.matches,

['foobar'])

def test_file_should_not_appear_in_complete(self):

self.repl = FakeRepl({'autocomplete_mode': autocomplete.SIMPLE})

self.setInputLine("_")

self.assertTrue(self.repl.complete())

self.assertTrue(hasattr(self.repl.matches_iter,'matches'))

self.assertTrue('__file__' not in self.repl.matches_iter.matches)

class TestCliRepl(unittest.TestCase):

def setUp(self):

self.repl = FakeCliRepl()

def test_atbol(self):

self.assertTrue(self.repl.atbol())

self.repl.s = "\t\t"

self.assertTrue(self.repl.atbol())

self.repl.s = "\t\tnot an empty line"

self.assertFalse(self.repl.atbol())

def test_addstr(self):

self.repl.complete = Mock(True)

self.repl.s = "foo"

self.repl.addstr("bar")

self.assertEqual(self.repl.s, "foobar")

self.repl.cpos = 3

self.repl.addstr('buzz')

self.assertEqual(self.repl.s, "foobuzzbar")

class TestCliReplTab(unittest.TestCase):

def setUp(self):

self.repl = FakeCliRepl()

# 3 Types of tab complete

def test_simple_tab_complete(self):

self.repl.matches_iter = MagicMock()

if py3:

self.repl.matches_iter.__bool__.return_value = False

else:

self.repl.matches_iter.__nonzero__.return_value = False

self.repl.complete = Mock()

self.repl.print_line = Mock()

self.repl.matches_iter.is_cseq.return_value = False

self.repl.show_list = Mock()

self.repl.argspec = Mock()

self.repl.matches_iter.cur_line.return_value = (None, "foobar")

self.repl.s = "foo"

self.repl.tab()

self.assertTrue(self.repl.complete.called)

self.repl.complete.assert_called_with(tab=True)

self.assertEqual(self.repl.s, "foobar")

@skip("disabled while non-simple completion is disabled")

def test_substring_tab_complete(self):

self.repl.s = "bar"

self.repl.config.autocomplete_mode = autocomplete.FUZZY

self.repl.tab()

self.assertEqual(self.repl.s, "foobar")

self.repl.tab()

self.assertEqual(self.repl.s, "foofoobar")

@skip("disabled while non-simple completion is disabled")

def test_fuzzy_tab_complete(self):

self.repl.s = "br"

self.repl.config.autocomplete_mode = autocomplete.FUZZY

self.repl.tab()

self.assertEqual(self.repl.s, "foobar")

# Edge Cases

def test_normal_tab(self):

"""make sure pressing the tab key will

still in some cases add a tab"""

self.repl.s = ""

self.repl.config = Mock()

self.repl.config.tab_length = 4

self.repl.complete = Mock()

self.repl.print_line = Mock()

self.repl.tab()

self.assertEqual(self.repl.s, " ")

def test_back_parameter(self):

self.repl.matches_iter = Mock()

self.repl.matches_iter.matches = True

self.repl.matches_iter.previous.return_value = "previtem"

self.repl.matches_iter.is_cseq.return_value = False

self.repl.show_list = Mock()

self.repl.argspec = Mock()

self.repl.matches_iter.cur_line.return_value = (None, "previtem")

self.repl.print_line = Mock()

self.repl.s = "foo"

self.repl.cpos = 0

self.repl.tab(back=True)

self.assertTrue(self.repl.matches_iter.previous.called)

self.assertTrue(self.repl.s, "previtem")

# Attribute Tests

@skip("disabled while non-simple completion is disabled")

def test_fuzzy_attribute_tab_complete(self):

"""Test fuzzy attribute with no text"""

self.repl.s = "Foo."

self.repl.config.autocomplete_mode = autocomplete.FUZZY

self.repl.tab()

self.assertEqual(self.repl.s, "Foo.foobar")

@skip("disabled while non-simple completion is disabled")

def test_fuzzy_attribute_tab_complete2(self):

"""Test fuzzy attribute with some text"""

self.repl.s = "Foo.br"

self.repl.config.autocomplete_mode = autocomplete.FUZZY

self.repl.tab()

self.assertEqual(self.repl.s, "Foo.foobar")

# Expand Tests

def test_simple_expand(self):

self.repl.s = "f"

self.cpos = 0

self.repl.matches_iter = Mock()

self.repl.matches_iter.is_cseq.return_value = True

self.repl.matches_iter.substitute_cseq.return_value = (3, "foo")

self.repl.print_line = Mock()

self.repl.tab()

self.assertEqual(self.repl.s, "foo")

@skip("disabled while non-simple completion is disabled")

def test_substring_expand_forward(self):

self.repl.config.autocomplete_mode = autocomplete.SUBSTRING

self.repl.s = "ba"

self.repl.tab()

self.assertEqual(self.repl.s, "bar")

@skip("disabled while non-simple completion is disabled")

def test_fuzzy_expand(self):

pass

if __name__ == '__main__':

unittest.main()