Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

"""Test certbot.display.completer.""" 

import os 

try: 

import readline # pylint: disable=import-error 

except ImportError: 

import certbot.display.dummy_readline as readline # type: ignore 

import string 

import sys 

import unittest 

 

import mock 

from six.moves import reload_module # pylint: disable=import-error 

 

from acme.magic_typing import List # pylint: disable=unused-import, no-name-in-module 

import certbot.tests.util as test_util 

 

class CompleterTest(test_util.TempDirTestCase): 

"""Test certbot.display.completer.Completer.""" 

 

def setUp(self): 

super(CompleterTest, self).setUp() 

 

# directories must end with os.sep for completer to 

# search inside the directory for possible completions 

if self.tempdir[-1] != os.sep: 

self.tempdir += os.sep 

 

self.paths = [] # type: List[str] 

# create some files and directories in temp_dir 

for c in string.ascii_lowercase: 

path = os.path.join(self.tempdir, c) 

self.paths.append(path) 

if ord(c) % 2: 

os.mkdir(path) 

else: 

with open(path, 'w'): 

pass 

 

def test_complete(self): 

from certbot.display import completer 

my_completer = completer.Completer() 

num_paths = len(self.paths) 

 

for i in range(num_paths): 

completion = my_completer.complete(self.tempdir, i) 

self.assertTrue(completion in self.paths) 

self.paths.remove(completion) 

 

self.assertFalse(self.paths) 

completion = my_completer.complete(self.tempdir, num_paths) 

self.assertEqual(completion, None) 

 

@unittest.skipIf('readline' not in sys.modules, 

reason='Not relevant if readline is not available.') 

def test_import_error(self): 

original_readline = sys.modules['readline'] 

sys.modules['readline'] = None 

 

self.test_context_manager_with_unmocked_readline() 

 

sys.modules['readline'] = original_readline 

 

def test_context_manager_with_unmocked_readline(self): 

from certbot.display import completer 

reload_module(completer) 

 

original_completer = readline.get_completer() 

original_delims = readline.get_completer_delims() 

 

with completer.Completer(): 

pass 

 

self.assertEqual(readline.get_completer(), original_completer) 

self.assertEqual(readline.get_completer_delims(), original_delims) 

 

@mock.patch('certbot.display.completer.readline', autospec=True) 

def test_context_manager_libedit(self, mock_readline): 

mock_readline.__doc__ = 'libedit' 

self._test_context_manager_with_mock_readline(mock_readline) 

 

@mock.patch('certbot.display.completer.readline', autospec=True) 

def test_context_manager_readline(self, mock_readline): 

mock_readline.__doc__ = 'GNU readline' 

self._test_context_manager_with_mock_readline(mock_readline) 

 

def _test_context_manager_with_mock_readline(self, mock_readline): 

from certbot.display import completer 

 

mock_readline.parse_and_bind.side_effect = enable_tab_completion 

 

with completer.Completer(): 

pass 

 

self.assertTrue(mock_readline.parse_and_bind.called) 

 

 

def enable_tab_completion(unused_command): 

"""Enables readline tab completion using the system specific syntax.""" 

libedit = readline.__doc__ is not None and 'libedit' in readline.__doc__ 

command = 'bind ^I rl_complete' if libedit else 'tab: complete' 

readline.parse_and_bind(command) 

 

if __name__ == "__main__": 

unittest.main() # pragma: no cover