1 """Test config, coverage 93%.
2 (100% for IdleConfParser, IdleUserConfParser*, ConfigChanges).
3 * Exception is OSError clause in Save method.
4 Much of IdleConf is also exercised by ConfigDialog and test_configdialog.
5 """
6 from idlelib import config
7 import sys
8 import os
9 import tempfile
10 from test.support import captured_stderr, findfile
11 import unittest
12 from unittest import mock
13 import idlelib
14 from idlelib.idle_test.mock_idle import Func
15
16 # Tests should not depend on fortuitous user configurations.
17 # They must not affect actual user .cfg files.
18 # Replace user parsers with empty parsers that cannot be saved
19 # due to getting '' as the filename when created.
20
21 idleConf = config.idleConf
22 usercfg = idleConf.userCfg
23 testcfg = {}
24 usermain = testcfg['main'] = config.IdleUserConfParser('')
25 userhigh = testcfg['highlight'] = config.IdleUserConfParser('')
26 userkeys = testcfg['keys'] = config.IdleUserConfParser('')
27 userextn = testcfg['extensions'] = config.IdleUserConfParser('')
28
29 def setUpModule():
30 idleConf.userCfg = testcfg
31 idlelib.testing = True
32
33 def tearDownModule():
34 idleConf.userCfg = usercfg
35 idlelib.testing = False
36
37
38 class ESC[4;38;5;81mIdleConfParserTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
39 """Test that IdleConfParser works"""
40
41 config = """
42 [one]
43 one = false
44 two = true
45 three = 10
46
47 [two]
48 one = a string
49 two = true
50 three = false
51 """
52
53 def test_get(self):
54 parser = config.IdleConfParser('')
55 parser.read_string(self.config)
56 eq = self.assertEqual
57
58 # Test with type argument.
59 self.assertIs(parser.Get('one', 'one', type='bool'), False)
60 self.assertIs(parser.Get('one', 'two', type='bool'), True)
61 eq(parser.Get('one', 'three', type='int'), 10)
62 eq(parser.Get('two', 'one'), 'a string')
63 self.assertIs(parser.Get('two', 'two', type='bool'), True)
64 self.assertIs(parser.Get('two', 'three', type='bool'), False)
65
66 # Test without type should fallback to string.
67 eq(parser.Get('two', 'two'), 'true')
68 eq(parser.Get('two', 'three'), 'false')
69
70 # If option not exist, should return None, or default.
71 self.assertIsNone(parser.Get('not', 'exist'))
72 eq(parser.Get('not', 'exist', default='DEFAULT'), 'DEFAULT')
73
74 def test_get_option_list(self):
75 parser = config.IdleConfParser('')
76 parser.read_string(self.config)
77 get_list = parser.GetOptionList
78 self.assertCountEqual(get_list('one'), ['one', 'two', 'three'])
79 self.assertCountEqual(get_list('two'), ['one', 'two', 'three'])
80 self.assertEqual(get_list('not exist'), [])
81
82 def test_load_nothing(self):
83 parser = config.IdleConfParser('')
84 parser.Load()
85 self.assertEqual(parser.sections(), [])
86
87 def test_load_file(self):
88 # Borrow test/cfgparser.1 from test_configparser.
89 config_path = findfile('cfgparser.1')
90 parser = config.IdleConfParser(config_path)
91 parser.Load()
92
93 self.assertEqual(parser.Get('Foo Bar', 'foo'), 'newbar')
94 self.assertEqual(parser.GetOptionList('Foo Bar'), ['foo'])
95
96
97 class ESC[4;38;5;81mIdleUserConfParserTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
98 """Test that IdleUserConfParser works"""
99
100 def new_parser(self, path=''):
101 return config.IdleUserConfParser(path)
102
103 def test_set_option(self):
104 parser = self.new_parser()
105 parser.add_section('Foo')
106 # Setting new option in existing section should return True.
107 self.assertTrue(parser.SetOption('Foo', 'bar', 'true'))
108 # Setting existing option with same value should return False.
109 self.assertFalse(parser.SetOption('Foo', 'bar', 'true'))
110 # Setting exiting option with new value should return True.
111 self.assertTrue(parser.SetOption('Foo', 'bar', 'false'))
112 self.assertEqual(parser.Get('Foo', 'bar'), 'false')
113
114 # Setting option in new section should create section and return True.
115 self.assertTrue(parser.SetOption('Bar', 'bar', 'true'))
116 self.assertCountEqual(parser.sections(), ['Bar', 'Foo'])
117 self.assertEqual(parser.Get('Bar', 'bar'), 'true')
118
119 def test_remove_option(self):
120 parser = self.new_parser()
121 parser.AddSection('Foo')
122 parser.SetOption('Foo', 'bar', 'true')
123
124 self.assertTrue(parser.RemoveOption('Foo', 'bar'))
125 self.assertFalse(parser.RemoveOption('Foo', 'bar'))
126 self.assertFalse(parser.RemoveOption('Not', 'Exist'))
127
128 def test_add_section(self):
129 parser = self.new_parser()
130 self.assertEqual(parser.sections(), [])
131
132 # Should not add duplicate section.
133 # Configparser raises DuplicateError, IdleParser not.
134 parser.AddSection('Foo')
135 parser.AddSection('Foo')
136 parser.AddSection('Bar')
137 self.assertCountEqual(parser.sections(), ['Bar', 'Foo'])
138
139 def test_remove_empty_sections(self):
140 parser = self.new_parser()
141
142 parser.AddSection('Foo')
143 parser.AddSection('Bar')
144 parser.SetOption('Idle', 'name', 'val')
145 self.assertCountEqual(parser.sections(), ['Bar', 'Foo', 'Idle'])
146 parser.RemoveEmptySections()
147 self.assertEqual(parser.sections(), ['Idle'])
148
149 def test_is_empty(self):
150 parser = self.new_parser()
151
152 parser.AddSection('Foo')
153 parser.AddSection('Bar')
154 self.assertTrue(parser.IsEmpty())
155 self.assertEqual(parser.sections(), [])
156
157 parser.SetOption('Foo', 'bar', 'false')
158 parser.AddSection('Bar')
159 self.assertFalse(parser.IsEmpty())
160 self.assertCountEqual(parser.sections(), ['Foo'])
161
162 def test_save(self):
163 with tempfile.TemporaryDirectory() as tdir:
164 path = os.path.join(tdir, 'test.cfg')
165 parser = self.new_parser(path)
166 parser.AddSection('Foo')
167 parser.SetOption('Foo', 'bar', 'true')
168
169 # Should save to path when config is not empty.
170 self.assertFalse(os.path.exists(path))
171 parser.Save()
172 self.assertTrue(os.path.exists(path))
173
174 # Should remove the file from disk when config is empty.
175 parser.remove_section('Foo')
176 parser.Save()
177 self.assertFalse(os.path.exists(path))
178
179
180 class ESC[4;38;5;81mIdleConfTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
181 """Test for idleConf"""
182
183 @classmethod
184 def setUpClass(cls):
185 cls.config_string = {}
186
187 conf = config.IdleConf(_utest=True)
188 if __name__ != '__main__':
189 idle_dir = os.path.dirname(__file__)
190 else:
191 idle_dir = os.path.abspath(sys.path[0])
192 for ctype in conf.config_types:
193 config_path = os.path.join(idle_dir, '../config-%s.def' % ctype)
194 with open(config_path) as f:
195 cls.config_string[ctype] = f.read()
196
197 cls.orig_warn = config._warn
198 config._warn = Func()
199
200 @classmethod
201 def tearDownClass(cls):
202 config._warn = cls.orig_warn
203
204 def new_config(self, _utest=False):
205 return config.IdleConf(_utest=_utest)
206
207 def mock_config(self):
208 """Return a mocked idleConf
209
210 Both default and user config used the same config-*.def
211 """
212 conf = config.IdleConf(_utest=True)
213 for ctype in conf.config_types:
214 conf.defaultCfg[ctype] = config.IdleConfParser('')
215 conf.defaultCfg[ctype].read_string(self.config_string[ctype])
216 conf.userCfg[ctype] = config.IdleUserConfParser('')
217 conf.userCfg[ctype].read_string(self.config_string[ctype])
218
219 return conf
220
221 @unittest.skipIf(sys.platform.startswith('win'), 'this is test for unix system')
222 def test_get_user_cfg_dir_unix(self):
223 # Test to get user config directory under unix.
224 conf = self.new_config(_utest=True)
225
226 # Check normal way should success
227 with mock.patch('os.path.expanduser', return_value='/home/foo'):
228 with mock.patch('os.path.exists', return_value=True):
229 self.assertEqual(conf.GetUserCfgDir(), '/home/foo/.idlerc')
230
231 # Check os.getcwd should success
232 with mock.patch('os.path.expanduser', return_value='~'):
233 with mock.patch('os.getcwd', return_value='/home/foo/cpython'):
234 with mock.patch('os.mkdir'):
235 self.assertEqual(conf.GetUserCfgDir(),
236 '/home/foo/cpython/.idlerc')
237
238 # Check user dir not exists and created failed should raise SystemExit
239 with mock.patch('os.path.join', return_value='/path/not/exists'):
240 with self.assertRaises(SystemExit):
241 with self.assertRaises(FileNotFoundError):
242 conf.GetUserCfgDir()
243
244 @unittest.skipIf(not sys.platform.startswith('win'), 'this is test for Windows system')
245 def test_get_user_cfg_dir_windows(self):
246 # Test to get user config directory under Windows.
247 conf = self.new_config(_utest=True)
248
249 # Check normal way should success
250 with mock.patch('os.path.expanduser', return_value='C:\\foo'):
251 with mock.patch('os.path.exists', return_value=True):
252 self.assertEqual(conf.GetUserCfgDir(), 'C:\\foo\\.idlerc')
253
254 # Check os.getcwd should success
255 with mock.patch('os.path.expanduser', return_value='~'):
256 with mock.patch('os.getcwd', return_value='C:\\foo\\cpython'):
257 with mock.patch('os.mkdir'):
258 self.assertEqual(conf.GetUserCfgDir(),
259 'C:\\foo\\cpython\\.idlerc')
260
261 # Check user dir not exists and created failed should raise SystemExit
262 with mock.patch('os.path.join', return_value='/path/not/exists'):
263 with self.assertRaises(SystemExit):
264 with self.assertRaises(FileNotFoundError):
265 conf.GetUserCfgDir()
266
267 def test_create_config_handlers(self):
268 conf = self.new_config(_utest=True)
269
270 # Mock out idle_dir
271 idle_dir = '/home/foo'
272 with mock.patch.dict({'__name__': '__foo__'}):
273 with mock.patch('os.path.dirname', return_value=idle_dir):
274 conf.CreateConfigHandlers()
275
276 # Check keys are equal
277 self.assertCountEqual(conf.defaultCfg.keys(), conf.config_types)
278 self.assertCountEqual(conf.userCfg.keys(), conf.config_types)
279
280 # Check conf parser are correct type
281 for default_parser in conf.defaultCfg.values():
282 self.assertIsInstance(default_parser, config.IdleConfParser)
283 for user_parser in conf.userCfg.values():
284 self.assertIsInstance(user_parser, config.IdleUserConfParser)
285
286 # Check config path are correct
287 for cfg_type, parser in conf.defaultCfg.items():
288 self.assertEqual(parser.file,
289 os.path.join(idle_dir, f'config-{cfg_type}.def'))
290 for cfg_type, parser in conf.userCfg.items():
291 self.assertEqual(parser.file,
292 os.path.join(conf.userdir or '#', f'config-{cfg_type}.cfg'))
293
294 def test_load_cfg_files(self):
295 conf = self.new_config(_utest=True)
296
297 # Borrow test/cfgparser.1 from test_configparser.
298 config_path = findfile('cfgparser.1')
299 conf.defaultCfg['foo'] = config.IdleConfParser(config_path)
300 conf.userCfg['foo'] = config.IdleUserConfParser(config_path)
301
302 # Load all config from path
303 conf.LoadCfgFiles()
304
305 eq = self.assertEqual
306
307 # Check defaultCfg is loaded
308 eq(conf.defaultCfg['foo'].Get('Foo Bar', 'foo'), 'newbar')
309 eq(conf.defaultCfg['foo'].GetOptionList('Foo Bar'), ['foo'])
310
311 # Check userCfg is loaded
312 eq(conf.userCfg['foo'].Get('Foo Bar', 'foo'), 'newbar')
313 eq(conf.userCfg['foo'].GetOptionList('Foo Bar'), ['foo'])
314
315 def test_save_user_cfg_files(self):
316 conf = self.mock_config()
317
318 with mock.patch('idlelib.config.IdleUserConfParser.Save') as m:
319 conf.SaveUserCfgFiles()
320 self.assertEqual(m.call_count, len(conf.userCfg))
321
322 def test_get_option(self):
323 conf = self.mock_config()
324
325 eq = self.assertEqual
326 eq(conf.GetOption('main', 'EditorWindow', 'width'), '80')
327 eq(conf.GetOption('main', 'EditorWindow', 'width', type='int'), 80)
328 with mock.patch('idlelib.config._warn') as _warn:
329 eq(conf.GetOption('main', 'EditorWindow', 'font', type='int'), None)
330 eq(conf.GetOption('main', 'EditorWindow', 'NotExists'), None)
331 eq(conf.GetOption('main', 'EditorWindow', 'NotExists', default='NE'), 'NE')
332 eq(_warn.call_count, 4)
333
334 def test_set_option(self):
335 conf = self.mock_config()
336
337 conf.SetOption('main', 'Foo', 'bar', 'newbar')
338 self.assertEqual(conf.GetOption('main', 'Foo', 'bar'), 'newbar')
339
340 def test_get_section_list(self):
341 conf = self.mock_config()
342
343 self.assertCountEqual(
344 conf.GetSectionList('default', 'main'),
345 ['General', 'EditorWindow', 'PyShell', 'Indent', 'Theme',
346 'Keys', 'History', 'HelpFiles'])
347 self.assertCountEqual(
348 conf.GetSectionList('user', 'main'),
349 ['General', 'EditorWindow', 'PyShell', 'Indent', 'Theme',
350 'Keys', 'History', 'HelpFiles'])
351
352 with self.assertRaises(config.InvalidConfigSet):
353 conf.GetSectionList('foobar', 'main')
354 with self.assertRaises(config.InvalidConfigType):
355 conf.GetSectionList('default', 'notexists')
356
357 def test_get_highlight(self):
358 conf = self.mock_config()
359
360 eq = self.assertEqual
361 eq(conf.GetHighlight('IDLE Classic', 'normal'), {'foreground': '#000000',
362 'background': '#ffffff'})
363
364 # Test cursor (this background should be normal-background)
365 eq(conf.GetHighlight('IDLE Classic', 'cursor'), {'foreground': 'black',
366 'background': '#ffffff'})
367
368 # Test get user themes
369 conf.SetOption('highlight', 'Foobar', 'normal-foreground', '#747474')
370 conf.SetOption('highlight', 'Foobar', 'normal-background', '#171717')
371 with mock.patch('idlelib.config._warn'):
372 eq(conf.GetHighlight('Foobar', 'normal'), {'foreground': '#747474',
373 'background': '#171717'})
374
375 def test_get_theme_dict(self):
376 # TODO: finish.
377 conf = self.mock_config()
378
379 # These two should be the same
380 self.assertEqual(
381 conf.GetThemeDict('default', 'IDLE Classic'),
382 conf.GetThemeDict('user', 'IDLE Classic'))
383
384 with self.assertRaises(config.InvalidTheme):
385 conf.GetThemeDict('bad', 'IDLE Classic')
386
387 def test_get_current_theme_and_keys(self):
388 conf = self.mock_config()
389
390 self.assertEqual(conf.CurrentTheme(), conf.current_colors_and_keys('Theme'))
391 self.assertEqual(conf.CurrentKeys(), conf.current_colors_and_keys('Keys'))
392
393 def test_current_colors_and_keys(self):
394 conf = self.mock_config()
395
396 self.assertEqual(conf.current_colors_and_keys('Theme'), 'IDLE Classic')
397
398 def test_default_keys(self):
399 current_platform = sys.platform
400 conf = self.new_config(_utest=True)
401
402 sys.platform = 'win32'
403 self.assertEqual(conf.default_keys(), 'IDLE Classic Windows')
404
405 sys.platform = 'darwin'
406 self.assertEqual(conf.default_keys(), 'IDLE Classic OSX')
407
408 sys.platform = 'some-linux'
409 self.assertEqual(conf.default_keys(), 'IDLE Modern Unix')
410
411 # Restore platform
412 sys.platform = current_platform
413
414 def test_get_extensions(self):
415 userextn.read_string('''
416 [ZzDummy]
417 enable = True
418 [DISABLE]
419 enable = False
420 ''')
421 eq = self.assertEqual
422 iGE = idleConf.GetExtensions
423 eq(iGE(shell_only=True), [])
424 eq(iGE(), ['ZzDummy'])
425 eq(iGE(editor_only=True), ['ZzDummy'])
426 eq(iGE(active_only=False), ['ZzDummy', 'DISABLE'])
427 eq(iGE(active_only=False, editor_only=True), ['ZzDummy', 'DISABLE'])
428 userextn.remove_section('ZzDummy')
429 userextn.remove_section('DISABLE')
430
431
432 def test_remove_key_bind_names(self):
433 conf = self.mock_config()
434
435 self.assertCountEqual(
436 conf.RemoveKeyBindNames(conf.GetSectionList('default', 'extensions')),
437 ['AutoComplete', 'CodeContext', 'FormatParagraph', 'ParenMatch', 'ZzDummy'])
438
439 def test_get_extn_name_for_event(self):
440 userextn.read_string('''
441 [ZzDummy]
442 enable = True
443 ''')
444 eq = self.assertEqual
445 eq(idleConf.GetExtnNameForEvent('z-in'), 'ZzDummy')
446 eq(idleConf.GetExtnNameForEvent('z-out'), None)
447 userextn.remove_section('ZzDummy')
448
449 def test_get_extension_keys(self):
450 userextn.read_string('''
451 [ZzDummy]
452 enable = True
453 ''')
454 self.assertEqual(idleConf.GetExtensionKeys('ZzDummy'),
455 {'<<z-in>>': ['<Control-Shift-KeyRelease-Insert>']})
456 userextn.remove_section('ZzDummy')
457 # need option key test
458 ## key = ['<Option-Key-2>'] if sys.platform == 'darwin' else ['<Alt-Key-2>']
459 ## eq(conf.GetExtensionKeys('ZoomHeight'), {'<<zoom-height>>': key})
460
461 def test_get_extension_bindings(self):
462 userextn.read_string('''
463 [ZzDummy]
464 enable = True
465 ''')
466 eq = self.assertEqual
467 iGEB = idleConf.GetExtensionBindings
468 eq(iGEB('NotExists'), {})
469 expect = {'<<z-in>>': ['<Control-Shift-KeyRelease-Insert>'],
470 '<<z-out>>': ['<Control-Shift-KeyRelease-Delete>']}
471 eq(iGEB('ZzDummy'), expect)
472 userextn.remove_section('ZzDummy')
473
474 def test_get_keybinding(self):
475 conf = self.mock_config()
476
477 eq = self.assertEqual
478 eq(conf.GetKeyBinding('IDLE Modern Unix', '<<copy>>'),
479 ['<Control-Shift-Key-C>', '<Control-Key-Insert>'])
480 eq(conf.GetKeyBinding('IDLE Classic Unix', '<<copy>>'),
481 ['<Alt-Key-w>', '<Meta-Key-w>'])
482 eq(conf.GetKeyBinding('IDLE Classic Windows', '<<copy>>'),
483 ['<Control-Key-c>', '<Control-Key-C>'])
484 eq(conf.GetKeyBinding('IDLE Classic Mac', '<<copy>>'), ['<Command-Key-c>'])
485 eq(conf.GetKeyBinding('IDLE Classic OSX', '<<copy>>'), ['<Command-Key-c>'])
486
487 # Test keybinding not exists
488 eq(conf.GetKeyBinding('NOT EXISTS', '<<copy>>'), [])
489 eq(conf.GetKeyBinding('IDLE Modern Unix', 'NOT EXISTS'), [])
490
491 def test_get_current_keyset(self):
492 current_platform = sys.platform
493 conf = self.mock_config()
494
495 # Ensure that platform isn't darwin
496 sys.platform = 'some-linux'
497 self.assertEqual(conf.GetCurrentKeySet(), conf.GetKeySet(conf.CurrentKeys()))
498
499 # This should not be the same, since replace <Alt- to <Option-.
500 # Above depended on config-extensions.def having Alt keys,
501 # which is no longer true.
502 # sys.platform = 'darwin'
503 # self.assertNotEqual(conf.GetCurrentKeySet(), conf.GetKeySet(conf.CurrentKeys()))
504
505 # Restore platform
506 sys.platform = current_platform
507
508 def test_get_keyset(self):
509 conf = self.mock_config()
510
511 # Conflict with key set, should be disable to ''
512 conf.defaultCfg['extensions'].add_section('Foobar')
513 conf.defaultCfg['extensions'].add_section('Foobar_cfgBindings')
514 conf.defaultCfg['extensions'].set('Foobar', 'enable', 'True')
515 conf.defaultCfg['extensions'].set('Foobar_cfgBindings', 'newfoo', '<Key-F3>')
516 self.assertEqual(conf.GetKeySet('IDLE Modern Unix')['<<newfoo>>'], '')
517
518 def test_is_core_binding(self):
519 # XXX: Should move out the core keys to config file or other place
520 conf = self.mock_config()
521
522 self.assertTrue(conf.IsCoreBinding('copy'))
523 self.assertTrue(conf.IsCoreBinding('cut'))
524 self.assertTrue(conf.IsCoreBinding('del-word-right'))
525 self.assertFalse(conf.IsCoreBinding('not-exists'))
526
527 def test_extra_help_source_list(self):
528 # Test GetExtraHelpSourceList and GetAllExtraHelpSourcesList in same
529 # place to prevent prepare input data twice.
530 conf = self.mock_config()
531
532 # Test default with no extra help source
533 self.assertEqual(conf.GetExtraHelpSourceList('default'), [])
534 self.assertEqual(conf.GetExtraHelpSourceList('user'), [])
535 with self.assertRaises(config.InvalidConfigSet):
536 self.assertEqual(conf.GetExtraHelpSourceList('bad'), [])
537 self.assertCountEqual(
538 conf.GetAllExtraHelpSourcesList(),
539 conf.GetExtraHelpSourceList('default') + conf.GetExtraHelpSourceList('user'))
540
541 # Add help source to user config
542 conf.userCfg['main'].SetOption('HelpFiles', '4', 'Python;https://python.org') # This is bad input
543 conf.userCfg['main'].SetOption('HelpFiles', '3', 'Python:https://python.org') # This is bad input
544 conf.userCfg['main'].SetOption('HelpFiles', '2', 'Pillow;https://pillow.readthedocs.io/en/latest/')
545 conf.userCfg['main'].SetOption('HelpFiles', '1', 'IDLE;C:/Programs/Python36/Lib/idlelib/help.html')
546 self.assertEqual(conf.GetExtraHelpSourceList('user'),
547 [('IDLE', 'C:/Programs/Python36/Lib/idlelib/help.html', '1'),
548 ('Pillow', 'https://pillow.readthedocs.io/en/latest/', '2'),
549 ('Python', 'https://python.org', '4')])
550 self.assertCountEqual(
551 conf.GetAllExtraHelpSourcesList(),
552 conf.GetExtraHelpSourceList('default') + conf.GetExtraHelpSourceList('user'))
553
554 def test_get_font(self):
555 from test.support import requires
556 from tkinter import Tk
557 from tkinter.font import Font
558 conf = self.mock_config()
559
560 requires('gui')
561 root = Tk()
562 root.withdraw()
563
564 f = Font.actual(Font(name='TkFixedFont', exists=True, root=root))
565 self.assertEqual(
566 conf.GetFont(root, 'main', 'EditorWindow'),
567 (f['family'], 10 if f['size'] <= 0 else f['size'], f['weight']))
568
569 # Cleanup root
570 root.destroy()
571 del root
572
573 def test_get_core_keys(self):
574 conf = self.mock_config()
575
576 eq = self.assertEqual
577 eq(conf.GetCoreKeys()['<<center-insert>>'], ['<Control-l>'])
578 eq(conf.GetCoreKeys()['<<copy>>'], ['<Control-c>', '<Control-C>'])
579 eq(conf.GetCoreKeys()['<<history-next>>'], ['<Alt-n>'])
580 eq(conf.GetCoreKeys('IDLE Classic Windows')['<<center-insert>>'],
581 ['<Control-Key-l>', '<Control-Key-L>'])
582 eq(conf.GetCoreKeys('IDLE Classic OSX')['<<copy>>'], ['<Command-Key-c>'])
583 eq(conf.GetCoreKeys('IDLE Classic Unix')['<<history-next>>'],
584 ['<Alt-Key-n>', '<Meta-Key-n>'])
585 eq(conf.GetCoreKeys('IDLE Modern Unix')['<<history-next>>'],
586 ['<Alt-Key-n>', '<Meta-Key-n>'])
587
588
589 class ESC[4;38;5;81mCurrentColorKeysTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
590 """ Test colorkeys function with user config [Theme] and [Keys] patterns.
591
592 colorkeys = config.IdleConf.current_colors_and_keys
593 Test all patterns written by IDLE and some errors
594 Item 'default' should really be 'builtin' (versus 'custom).
595 """
596 colorkeys = idleConf.current_colors_and_keys
597 default_theme = 'IDLE Classic'
598 default_keys = idleConf.default_keys()
599
600 def test_old_builtin_theme(self):
601 # On initial installation, user main is blank.
602 self.assertEqual(self.colorkeys('Theme'), self.default_theme)
603 # For old default, name2 must be blank.
604 usermain.read_string('''
605 [Theme]
606 default = True
607 ''')
608 # IDLE omits 'name' for default old builtin theme.
609 self.assertEqual(self.colorkeys('Theme'), self.default_theme)
610 # IDLE adds 'name' for non-default old builtin theme.
611 usermain['Theme']['name'] = 'IDLE New'
612 self.assertEqual(self.colorkeys('Theme'), 'IDLE New')
613 # Erroneous non-default old builtin reverts to default.
614 usermain['Theme']['name'] = 'non-existent'
615 self.assertEqual(self.colorkeys('Theme'), self.default_theme)
616 usermain.remove_section('Theme')
617
618 def test_new_builtin_theme(self):
619 # IDLE writes name2 for new builtins.
620 usermain.read_string('''
621 [Theme]
622 default = True
623 name2 = IDLE Dark
624 ''')
625 self.assertEqual(self.colorkeys('Theme'), 'IDLE Dark')
626 # Leftover 'name', not removed, is ignored.
627 usermain['Theme']['name'] = 'IDLE New'
628 self.assertEqual(self.colorkeys('Theme'), 'IDLE Dark')
629 # Erroneous non-default new builtin reverts to default.
630 usermain['Theme']['name2'] = 'non-existent'
631 self.assertEqual(self.colorkeys('Theme'), self.default_theme)
632 usermain.remove_section('Theme')
633
634 def test_user_override_theme(self):
635 # Erroneous custom name (no definition) reverts to default.
636 usermain.read_string('''
637 [Theme]
638 default = False
639 name = Custom Dark
640 ''')
641 self.assertEqual(self.colorkeys('Theme'), self.default_theme)
642 # Custom name is valid with matching Section name.
643 userhigh.read_string('[Custom Dark]\na=b')
644 self.assertEqual(self.colorkeys('Theme'), 'Custom Dark')
645 # Name2 is ignored.
646 usermain['Theme']['name2'] = 'non-existent'
647 self.assertEqual(self.colorkeys('Theme'), 'Custom Dark')
648 usermain.remove_section('Theme')
649 userhigh.remove_section('Custom Dark')
650
651 def test_old_builtin_keys(self):
652 # On initial installation, user main is blank.
653 self.assertEqual(self.colorkeys('Keys'), self.default_keys)
654 # For old default, name2 must be blank, name is always used.
655 usermain.read_string('''
656 [Keys]
657 default = True
658 name = IDLE Classic Unix
659 ''')
660 self.assertEqual(self.colorkeys('Keys'), 'IDLE Classic Unix')
661 # Erroneous non-default old builtin reverts to default.
662 usermain['Keys']['name'] = 'non-existent'
663 self.assertEqual(self.colorkeys('Keys'), self.default_keys)
664 usermain.remove_section('Keys')
665
666 def test_new_builtin_keys(self):
667 # IDLE writes name2 for new builtins.
668 usermain.read_string('''
669 [Keys]
670 default = True
671 name2 = IDLE Modern Unix
672 ''')
673 self.assertEqual(self.colorkeys('Keys'), 'IDLE Modern Unix')
674 # Leftover 'name', not removed, is ignored.
675 usermain['Keys']['name'] = 'IDLE Classic Unix'
676 self.assertEqual(self.colorkeys('Keys'), 'IDLE Modern Unix')
677 # Erroneous non-default new builtin reverts to default.
678 usermain['Keys']['name2'] = 'non-existent'
679 self.assertEqual(self.colorkeys('Keys'), self.default_keys)
680 usermain.remove_section('Keys')
681
682 def test_user_override_keys(self):
683 # Erroneous custom name (no definition) reverts to default.
684 usermain.read_string('''
685 [Keys]
686 default = False
687 name = Custom Keys
688 ''')
689 self.assertEqual(self.colorkeys('Keys'), self.default_keys)
690 # Custom name is valid with matching Section name.
691 userkeys.read_string('[Custom Keys]\na=b')
692 self.assertEqual(self.colorkeys('Keys'), 'Custom Keys')
693 # Name2 is ignored.
694 usermain['Keys']['name2'] = 'non-existent'
695 self.assertEqual(self.colorkeys('Keys'), 'Custom Keys')
696 usermain.remove_section('Keys')
697 userkeys.remove_section('Custom Keys')
698
699
700 class ESC[4;38;5;81mChangesTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
701
702 empty = {'main':{}, 'highlight':{}, 'keys':{}, 'extensions':{}}
703
704 def load(self): # Test_add_option verifies that this works.
705 changes = self.changes
706 changes.add_option('main', 'Msec', 'mitem', 'mval')
707 changes.add_option('highlight', 'Hsec', 'hitem', 'hval')
708 changes.add_option('keys', 'Ksec', 'kitem', 'kval')
709 return changes
710
711 loaded = {'main': {'Msec': {'mitem': 'mval'}},
712 'highlight': {'Hsec': {'hitem': 'hval'}},
713 'keys': {'Ksec': {'kitem':'kval'}},
714 'extensions': {}}
715
716 def setUp(self):
717 self.changes = config.ConfigChanges()
718
719 def test_init(self):
720 self.assertEqual(self.changes, self.empty)
721
722 def test_add_option(self):
723 changes = self.load()
724 self.assertEqual(changes, self.loaded)
725 changes.add_option('main', 'Msec', 'mitem', 'mval')
726 self.assertEqual(changes, self.loaded)
727
728 def test_save_option(self): # Static function does not touch changes.
729 save_option = self.changes.save_option
730 self.assertTrue(save_option('main', 'Indent', 'what', '0'))
731 self.assertFalse(save_option('main', 'Indent', 'what', '0'))
732 self.assertEqual(usermain['Indent']['what'], '0')
733
734 self.assertTrue(save_option('main', 'Indent', 'use-spaces', '0'))
735 self.assertEqual(usermain['Indent']['use-spaces'], '0')
736 self.assertTrue(save_option('main', 'Indent', 'use-spaces', '1'))
737 self.assertFalse(usermain.has_option('Indent', 'use-spaces'))
738 usermain.remove_section('Indent')
739
740 def test_save_added(self):
741 changes = self.load()
742 self.assertTrue(changes.save_all())
743 self.assertEqual(usermain['Msec']['mitem'], 'mval')
744 self.assertEqual(userhigh['Hsec']['hitem'], 'hval')
745 self.assertEqual(userkeys['Ksec']['kitem'], 'kval')
746 changes.add_option('main', 'Msec', 'mitem', 'mval')
747 self.assertFalse(changes.save_all())
748 usermain.remove_section('Msec')
749 userhigh.remove_section('Hsec')
750 userkeys.remove_section('Ksec')
751
752 def test_save_help(self):
753 # Any change to HelpFiles overwrites entire section.
754 changes = self.changes
755 changes.save_option('main', 'HelpFiles', 'IDLE', 'idledoc')
756 changes.add_option('main', 'HelpFiles', 'ELDI', 'codeldi')
757 changes.save_all()
758 self.assertFalse(usermain.has_option('HelpFiles', 'IDLE'))
759 self.assertTrue(usermain.has_option('HelpFiles', 'ELDI'))
760
761 def test_save_default(self): # Cover 2nd and 3rd false branches.
762 changes = self.changes
763 changes.add_option('main', 'Indent', 'use-spaces', '1')
764 # save_option returns False; cfg_type_changed remains False.
765
766 # TODO: test that save_all calls usercfg Saves.
767
768 def test_delete_section(self):
769 changes = self.load()
770 changes.delete_section('main', 'fake') # Test no exception.
771 self.assertEqual(changes, self.loaded) # Test nothing deleted.
772 for cfgtype, section in (('main', 'Msec'), ('keys', 'Ksec')):
773 testcfg[cfgtype].SetOption(section, 'name', 'value')
774 changes.delete_section(cfgtype, section)
775 with self.assertRaises(KeyError):
776 changes[cfgtype][section] # Test section gone from changes
777 testcfg[cfgtype][section] # and from mock userCfg.
778 # TODO test for save call.
779
780 def test_clear(self):
781 changes = self.load()
782 changes.clear()
783 self.assertEqual(changes, self.empty)
784
785
786 class ESC[4;38;5;81mWarningTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
787
788 def test_warn(self):
789 Equal = self.assertEqual
790 config._warned = set()
791 with captured_stderr() as stderr:
792 config._warn('warning', 'key')
793 Equal(config._warned, {('warning','key')})
794 Equal(stderr.getvalue(), 'warning'+'\n')
795 with captured_stderr() as stderr:
796 config._warn('warning', 'key')
797 Equal(stderr.getvalue(), '')
798 with captured_stderr() as stderr:
799 config._warn('warn2', 'yek')
800 Equal(config._warned, {('warning','key'), ('warn2','yek')})
801 Equal(stderr.getvalue(), 'warn2'+'\n')
802
803
804 if __name__ == '__main__':
805 unittest.main(verbosity=2)