Debian Codegraph @

Lib/idlelib/idle_test/test_configdialog.py

raw
1 """Test configdialog, coverage 94%.
2
3 Half the class creates dialog, half works with user customizations.
4 """
5 from idlelib import configdialog
6 from test.support import requires
7 requires('gui')
8 import unittest
9 from unittest import mock
10 from idlelib.idle_test.mock_idle import Func
11 from tkinter import (Tk, StringVar, IntVar, BooleanVar, DISABLED, NORMAL)
12 from idlelib import config
13 from idlelib.configdialog import idleConf, changes, tracers
14
15 # Tests should not depend on fortuitous user configurations.
16 # They must not affect actual user .cfg files.
17 # Use solution from test_config: empty parsers with no filename.
18 usercfg = idleConf.userCfg
19 testcfg = {
20 'main': config.IdleUserConfParser(''),
21 'highlight': config.IdleUserConfParser(''),
22 'keys': config.IdleUserConfParser(''),
23 'extensions': config.IdleUserConfParser(''),
24 }
25
26 root = None
27 dialog = None
28 mainpage = changes['main']
29 highpage = changes['highlight']
30 keyspage = changes['keys']
31 extpage = changes['extensions']
32
33
34 def setUpModule():
35 global root, dialog
36 idleConf.userCfg = testcfg
37 root = Tk()
38 # root.withdraw() # Comment out, see issue 30870
39 dialog = configdialog.ConfigDialog(root, 'Test', _utest=True)
40
41
42 def tearDownModule():
43 global root, dialog
44 idleConf.userCfg = usercfg
45 tracers.detach()
46 tracers.clear()
47 changes.clear()
48 root.update_idletasks()
49 root.destroy()
50 root = dialog = None
51
52
53 class ConfigDialogTest(unittest.TestCase):
54
55 def test_deactivate_current_config(self):
56 pass
57
58 def activate_config_changes(self):
59 pass
60
61
62 class ButtonTest(unittest.TestCase):
63
64 def test_click_ok(self):
65 d = dialog
66 apply = d.apply = mock.Mock()
67 destroy = d.destroy = mock.Mock()
68 d.buttons['Ok'].invoke()
69 apply.assert_called_once()
70 destroy.assert_called_once()
71 del d.destroy, d.apply
72
73 def test_click_apply(self):
74 d = dialog
75 deactivate = d.deactivate_current_config = mock.Mock()
76 save_ext = d.extpage.save_all_changed_extensions = mock.Mock()
77 activate = d.activate_config_changes = mock.Mock()
78 d.buttons['Apply'].invoke()
79 deactivate.assert_called_once()
80 save_ext.assert_called_once()
81 activate.assert_called_once()
82 del d.extpage.save_all_changed_extensions
83 del d.activate_config_changes, d.deactivate_current_config
84
85 def test_click_cancel(self):
86 d = dialog
87 d.destroy = Func()
88 changes['main']['something'] = 1
89 d.buttons['Cancel'].invoke()
90 self.assertEqual(changes['main'], {})
91 self.assertEqual(d.destroy.called, 1)
92 del d.destroy
93
94 def test_click_help(self):
95 dialog.note.select(dialog.keyspage)
96 with mock.patch.object(configdialog, 'view_text',
97 new_callable=Func) as view:
98 dialog.buttons['Help'].invoke()
99 title, contents = view.kwds['title'], view.kwds['contents']
100 self.assertEqual(title, 'Help for IDLE preferences')
101 self.assertStartsWith(contents, 'When you click')
102 self.assertEndsWith(contents,'a different name.\n')
103
104
105 class FontPageTest(unittest.TestCase):
106 """Test that font widgets enable users to make font changes.
107
108 Test that widget actions set vars, that var changes add three
109 options to changes and call set_samples, and that set_samples
110 changes the font of both sample boxes.
111 """
112 @classmethod
113 def setUpClass(cls):
114 page = cls.page = dialog.fontpage
115 dialog.note.select(page)
116 page.set_samples = Func() # Mask instance method.
117 page.update()
118
119 @classmethod
120 def tearDownClass(cls):
121 del cls.page.set_samples # Unmask instance method.
122
123 def setUp(self):
124 changes.clear()
125
126 def test_load_font_cfg(self):
127 # Leave widget load test to human visual check.
128 # TODO Improve checks when add IdleConf.get_font_values.
129 tracers.detach()
130 d = self.page
131 d.font_name.set('Fake')
132 d.font_size.set('1')
133 d.font_bold.set(True)
134 d.set_samples.called = 0
135 d.load_font_cfg()
136 self.assertNotEqual(d.font_name.get(), 'Fake')
137 self.assertNotEqual(d.font_size.get(), '1')
138 self.assertFalse(d.font_bold.get())
139 self.assertEqual(d.set_samples.called, 1)
140 tracers.attach()
141
142 def test_fontlist_key(self):
143 # Up and Down keys should select a new font.
144 d = self.page
145 if d.fontlist.size() < 2:
146 self.skipTest('need at least 2 fonts')
147 fontlist = d.fontlist
148 fontlist.activate(0)
149 font = d.fontlist.get('active')
150
151 # Test Down key.
152 fontlist.focus_force()
153 fontlist.update()
154 fontlist.event_generate('<Key-Down>')
155 fontlist.event_generate('<KeyRelease-Down>')
156
157 down_font = fontlist.get('active')
158 self.assertNotEqual(down_font, font)
159 self.assertIn(d.font_name.get(), down_font.lower())
160
161 # Test Up key.
162 fontlist.focus_force()
163 fontlist.update()
164 fontlist.event_generate('<Key-Up>')
165 fontlist.event_generate('<KeyRelease-Up>')
166
167 up_font = fontlist.get('active')
168 self.assertEqual(up_font, font)
169 self.assertIn(d.font_name.get(), up_font.lower())
170
171 def test_fontlist_mouse(self):
172 # Click on item should select that item.
173 d = self.page
174 if d.fontlist.size() < 2:
175 self.skipTest('need at least 2 fonts')
176 fontlist = d.fontlist
177 fontlist.activate(0)
178
179 # Select next item in listbox
180 fontlist.focus_force()
181 fontlist.see(1)
182 fontlist.update()
183 x, y, dx, dy = fontlist.bbox(1)
184 x += dx // 2
185 y += dy // 2
186 fontlist.event_generate('<Button-1>', x=x, y=y)
187 fontlist.event_generate('<ButtonRelease-1>', x=x, y=y)
188
189 font1 = fontlist.get(1)
190 select_font = fontlist.get('anchor')
191 self.assertEqual(select_font, font1)
192 self.assertIn(d.font_name.get(), font1.lower())
193
194 def test_sizelist(self):
195 # Click on number should select that number
196 d = self.page
197 d.sizelist.variable.set(40)
198 self.assertEqual(d.font_size.get(), '40')
199
200 def test_bold_toggle(self):
201 # Click on checkbutton should invert it.
202 d = self.page
203 d.font_bold.set(False)
204 d.bold_toggle.invoke()
205 self.assertTrue(d.font_bold.get())
206 d.bold_toggle.invoke()
207 self.assertFalse(d.font_bold.get())
208
209 def test_font_set(self):
210 # Test that setting a font Variable results in 3 provisional
211 # change entries and a call to set_samples. Use values sure to
212 # not be defaults.
213
214 default_font = idleConf.GetFont(root, 'main', 'EditorWindow')
215 default_size = str(default_font[1])
216 default_bold = default_font[2] == 'bold'
217 d = self.page
218 d.font_size.set(default_size)
219 d.font_bold.set(default_bold)
220 d.set_samples.called = 0
221
222 d.font_name.set('Test Font')
223 expected = {'EditorWindow': {'font': 'Test Font',
224 'font-size': default_size,
225 'font-bold': str(default_bold)}}
226 self.assertEqual(mainpage, expected)
227 self.assertEqual(d.set_samples.called, 1)
228 changes.clear()
229
230 d.font_size.set('20')
231 expected = {'EditorWindow': {'font': 'Test Font',
232 'font-size': '20',
233 'font-bold': str(default_bold)}}
234 self.assertEqual(mainpage, expected)
235 self.assertEqual(d.set_samples.called, 2)
236 changes.clear()
237
238 d.font_bold.set(not default_bold)
239 expected = {'EditorWindow': {'font': 'Test Font',
240 'font-size': '20',
241 'font-bold': str(not default_bold)}}
242 self.assertEqual(mainpage, expected)
243 self.assertEqual(d.set_samples.called, 3)
244
245 def test_set_samples(self):
246 d = self.page
247 del d.set_samples # Unmask method for test
248 orig_samples = d.font_sample, d.highlight_sample
249 d.font_sample, d.highlight_sample = {}, {}
250 d.font_name.set('test')
251 d.font_size.set('5')
252 d.font_bold.set(1)
253 expected = {'font': ('test', '5', 'bold')}
254
255 # Test set_samples.
256 d.set_samples()
257 self.assertTrue(d.font_sample == d.highlight_sample == expected)
258
259 d.font_sample, d.highlight_sample = orig_samples
260 d.set_samples = Func() # Re-mask for other tests.
261
262
263 class HighPageTest(unittest.TestCase):
264 """Test that highlight tab widgets enable users to make changes.
265
266 Test that widget actions set vars, that var changes add
267 options to changes and that themes work correctly.
268 """
269
270 @classmethod
271 def setUpClass(cls):
272 page = cls.page = dialog.highpage
273 dialog.note.select(page)
274 page.set_theme_type = Func()
275 page.paint_theme_sample = Func()
276 page.set_highlight_target = Func()
277 page.set_color_sample = Func()
278 page.update()
279
280 @classmethod
281 def tearDownClass(cls):
282 d = cls.page
283 del d.set_theme_type, d.paint_theme_sample
284 del d.set_highlight_target, d.set_color_sample
285
286 def setUp(self):
287 d = self.page
288 # The following is needed for test_load_key_cfg, _delete_custom_keys.
289 # This may indicate a defect in some test or function.
290 for section in idleConf.GetSectionList('user', 'highlight'):
291 idleConf.userCfg['highlight'].remove_section(section)
292 changes.clear()
293 d.set_theme_type.called = 0
294 d.paint_theme_sample.called = 0
295 d.set_highlight_target.called = 0
296 d.set_color_sample.called = 0
297
298 def test_load_theme_cfg(self):
299 tracers.detach()
300 d = self.page
301 eq = self.assertEqual
302
303 # Use builtin theme with no user themes created.
304 idleConf.CurrentTheme = mock.Mock(return_value='IDLE Classic')
305 d.load_theme_cfg()
306 self.assertTrue(d.theme_source.get())
307 # builtinlist sets variable builtin_name to the CurrentTheme default.
308 eq(d.builtin_name.get(), 'IDLE Classic')
309 eq(d.custom_name.get(), '- no custom themes -')
310 eq(d.custom_theme_on.state(), ('disabled',))
311 eq(d.set_theme_type.called, 1)
312 eq(d.paint_theme_sample.called, 1)
313 eq(d.set_highlight_target.called, 1)
314
315 # Builtin theme with non-empty user theme list.
316 idleConf.SetOption('highlight', 'test1', 'option', 'value')
317 idleConf.SetOption('highlight', 'test2', 'option2', 'value2')
318 d.load_theme_cfg()
319 eq(d.builtin_name.get(), 'IDLE Classic')
320 eq(d.custom_name.get(), 'test1')
321 eq(d.set_theme_type.called, 2)
322 eq(d.paint_theme_sample.called, 2)
323 eq(d.set_highlight_target.called, 2)
324
325 # Use custom theme.
326 idleConf.CurrentTheme = mock.Mock(return_value='test2')
327 idleConf.SetOption('main', 'Theme', 'default', '0')
328 d.load_theme_cfg()
329 self.assertFalse(d.theme_source.get())
330 eq(d.builtin_name.get(), 'IDLE Classic')
331 eq(d.custom_name.get(), 'test2')
332 eq(d.set_theme_type.called, 3)
333 eq(d.paint_theme_sample.called, 3)
334 eq(d.set_highlight_target.called, 3)
335
336 del idleConf.CurrentTheme
337 tracers.attach()
338
339 def test_theme_source(self):
340 eq = self.assertEqual
341 d = self.page
342 # Test these separately.
343 d.var_changed_builtin_name = Func()
344 d.var_changed_custom_name = Func()
345 # Builtin selected.
346 d.builtin_theme_on.invoke()
347 eq(mainpage, {'Theme': {'default': 'True'}})
348 eq(d.var_changed_builtin_name.called, 1)
349 eq(d.var_changed_custom_name.called, 0)
350 changes.clear()
351
352 # Custom selected.
353 d.custom_theme_on.state(('!disabled',))
354 d.custom_theme_on.invoke()
355 self.assertEqual(mainpage, {'Theme': {'default': 'False'}})
356 eq(d.var_changed_builtin_name.called, 1)
357 eq(d.var_changed_custom_name.called, 1)
358 del d.var_changed_builtin_name, d.var_changed_custom_name
359
360 def test_builtin_name(self):
361 eq = self.assertEqual
362 d = self.page
363 item_list = ['IDLE Classic', 'IDLE Dark', 'IDLE New']
364
365 # Not in old_themes, defaults name to first item.
366 idleConf.SetOption('main', 'Theme', 'name', 'spam')
367 d.builtinlist.SetMenu(item_list, 'IDLE Dark')
368 eq(mainpage, {'Theme': {'name': 'IDLE Classic',
369 'name2': 'IDLE Dark'}})
370 eq(d.theme_message['text'], 'New theme, see Help')
371 eq(d.paint_theme_sample.called, 1)
372
373 # Not in old themes - uses name2.
374 changes.clear()
375 idleConf.SetOption('main', 'Theme', 'name', 'IDLE New')
376 d.builtinlist.SetMenu(item_list, 'IDLE Dark')
377 eq(mainpage, {'Theme': {'name2': 'IDLE Dark'}})
378 eq(d.theme_message['text'], 'New theme, see Help')
379 eq(d.paint_theme_sample.called, 2)
380
381 # Builtin name in old_themes.
382 changes.clear()
383 d.builtinlist.SetMenu(item_list, 'IDLE Classic')
384 eq(mainpage, {'Theme': {'name': 'IDLE Classic', 'name2': ''}})
385 eq(d.theme_message['text'], '')
386 eq(d.paint_theme_sample.called, 3)
387
388 def test_custom_name(self):
389 d = self.page
390
391 # If no selections, doesn't get added.
392 d.customlist.SetMenu([], '- no custom themes -')
393 self.assertNotIn('Theme', mainpage)
394 self.assertEqual(d.paint_theme_sample.called, 0)
395
396 # Custom name selected.
397 changes.clear()
398 d.customlist.SetMenu(['a', 'b', 'c'], 'c')
399 self.assertEqual(mainpage, {'Theme': {'name': 'c'}})
400 self.assertEqual(d.paint_theme_sample.called, 1)
401
402 def test_color(self):
403 d = self.page
404 d.on_new_color_set = Func()
405 # self.color is only set in get_color through colorchooser.
406 d.color.set('green')
407 self.assertEqual(d.on_new_color_set.called, 1)
408 del d.on_new_color_set
409
410 def test_highlight_target_list_mouse(self):
411 # Set highlight_target through targetlist.
412 eq = self.assertEqual
413 d = self.page
414
415 d.targetlist.SetMenu(['a', 'b', 'c'], 'c')
416 eq(d.highlight_target.get(), 'c')
417 eq(d.set_highlight_target.called, 1)
418
419 def test_highlight_target_text_mouse(self):
420 # Set highlight_target through clicking highlight_sample.
421 eq = self.assertEqual
422 d = self.page
423 hs = d.highlight_sample
424 hs.focus_force()
425
426 def click_char(index):
427 "Simulate click on character at *index*."
428 hs.see(index)
429 hs.update_idletasks()
430 x, y, dx, dy = hs.bbox(index)
431 x += dx // 2
432 y += dy // 2
433 hs.event_generate('<Enter>', x=0, y=0)
434 hs.event_generate('<Motion>', x=x, y=y)
435 hs.event_generate('<ButtonPress-1>', x=x, y=y)
436 hs.event_generate('<ButtonRelease-1>', x=x, y=y)
437
438 # Reverse theme_elements to make the tag the key.
439 elem = {tag: element for element, tag in d.theme_elements.items()}
440
441 # If highlight_sample has a tag that isn't in theme_elements, there
442 # will be a KeyError in the test run.
443 count = 0
444 for tag in hs.tag_names():
445 try:
446 click_char(hs.tag_nextrange(tag, "1.0")[0])
447 eq(d.highlight_target.get(), elem[tag])
448 count += 1
449 eq(d.set_highlight_target.called, count)
450 except IndexError:
451 pass # Skip unused theme_elements tag, like 'sel'.
452
453 def test_highlight_sample_double_click(self):
454 # Test double click on highlight_sample.
455 eq = self.assertEqual
456 d = self.page
457
458 hs = d.highlight_sample
459 hs.focus_force()
460 hs.see(1.0)
461 hs.update_idletasks()
462
463 # Test binding from configdialog.
464 hs.event_generate('<Enter>', x=0, y=0)
465 hs.event_generate('<Motion>', x=0, y=0)
466 # Double click is a sequence of two clicks in a row.
467 for _ in range(2):
468 hs.event_generate('<ButtonPress-1>', x=0, y=0)
469 hs.event_generate('<ButtonRelease-1>', x=0, y=0)
470
471 eq(hs.tag_ranges('sel'), ())
472
473 def test_highlight_sample_b1_motion(self):
474 # Test button motion on highlight_sample.
475 eq = self.assertEqual
476 d = self.page
477
478 hs = d.highlight_sample
479 hs.focus_force()
480 hs.see(1.0)
481 hs.update_idletasks()
482
483 x, y, dx, dy, offset = hs.dlineinfo('1.0')
484
485 # Test binding from configdialog.
486 hs.event_generate('<Leave>')
487 hs.event_generate('<Enter>')
488 hs.event_generate('<Motion>', x=x, y=y)
489 hs.event_generate('<ButtonPress-1>', x=x, y=y)
490 hs.event_generate('<B1-Motion>', x=dx, y=dy)
491 hs.event_generate('<ButtonRelease-1>', x=dx, y=dy)
492
493 eq(hs.tag_ranges('sel'), ())
494
495 def test_set_theme_type(self):
496 eq = self.assertEqual
497 d = self.page
498 del d.set_theme_type
499
500 # Builtin theme selected.
501 d.theme_source.set(True)
502 d.set_theme_type()
503 eq(d.builtinlist['state'], NORMAL)
504 eq(d.customlist['state'], DISABLED)
505 eq(d.button_delete_custom.state(), ('disabled',))
506
507 # Custom theme selected.
508 d.theme_source.set(False)
509 d.set_theme_type()
510 eq(d.builtinlist['state'], DISABLED)
511 eq(d.custom_theme_on.state(), ('selected',))
512 eq(d.customlist['state'], NORMAL)
513 eq(d.button_delete_custom.state(), ())
514 d.set_theme_type = Func()
515
516 def test_get_color(self):
517 eq = self.assertEqual
518 d = self.page
519 orig_chooser = configdialog.colorchooser.askcolor
520 chooser = configdialog.colorchooser.askcolor = Func()
521 gntn = d.get_new_theme_name = Func()
522
523 d.highlight_target.set('Editor Breakpoint')
524 d.color.set('#ffffff')
525
526 # Nothing selected.
527 chooser.result = (None, None)
528 d.button_set_color.invoke()
529 eq(d.color.get(), '#ffffff')
530
531 # Selection same as previous color.
532 chooser.result = ('', d.style.lookup(d.frame_color_set['style'], 'background'))
533 d.button_set_color.invoke()
534 eq(d.color.get(), '#ffffff')
535
536 # Select different color.
537 chooser.result = ((222.8671875, 0.0, 0.0), '#de0000')
538
539 # Default theme.
540 d.color.set('#ffffff')
541 d.theme_source.set(True)
542
543 # No theme name selected therefore color not saved.
544 gntn.result = ''
545 d.button_set_color.invoke()
546 eq(gntn.called, 1)
547 eq(d.color.get(), '#ffffff')
548 # Theme name selected.
549 gntn.result = 'My New Theme'
550 d.button_set_color.invoke()
551 eq(d.custom_name.get(), gntn.result)
552 eq(d.color.get(), '#de0000')
553
554 # Custom theme.
555 d.color.set('#ffffff')
556 d.theme_source.set(False)
557 d.button_set_color.invoke()
558 eq(d.color.get(), '#de0000')
559
560 del d.get_new_theme_name
561 configdialog.colorchooser.askcolor = orig_chooser
562
563 def test_on_new_color_set(self):
564 d = self.page
565 color = '#3f7cae'
566 d.custom_name.set('Python')
567 d.highlight_target.set('Selected Text')
568 d.fg_bg_toggle.set(True)
569
570 d.color.set(color)
571 self.assertEqual(d.style.lookup(d.frame_color_set['style'], 'background'), color)
572 self.assertEqual(d.highlight_sample.tag_cget('hilite', 'foreground'), color)
573 self.assertEqual(highpage,
574 {'Python': {'hilite-foreground': color}})
575
576 def test_get_new_theme_name(self):
577 orig_sectionname = configdialog.SectionName
578 sn = configdialog.SectionName = Func(return_self=True)
579 d = self.page
580
581 sn.result = 'New Theme'
582 self.assertEqual(d.get_new_theme_name(''), 'New Theme')
583
584 configdialog.SectionName = orig_sectionname
585
586 def test_save_as_new_theme(self):
587 d = self.page
588 gntn = d.get_new_theme_name = Func()
589 d.theme_source.set(True)
590
591 # No name entered.
592 gntn.result = ''
593 d.button_save_custom.invoke()
594 self.assertNotIn(gntn.result, idleConf.userCfg['highlight'])
595
596 # Name entered.
597 gntn.result = 'my new theme'
598 gntn.called = 0
599 self.assertNotIn(gntn.result, idleConf.userCfg['highlight'])
600 d.button_save_custom.invoke()
601 self.assertIn(gntn.result, idleConf.userCfg['highlight'])
602
603 del d.get_new_theme_name
604
605 def test_create_new_and_save_new(self):
606 eq = self.assertEqual
607 d = self.page
608
609 # Use default as previously active theme.
610 d.theme_source.set(True)
611 d.builtin_name.set('IDLE Classic')
612 first_new = 'my new custom theme'
613 second_new = 'my second custom theme'
614
615 # No changes, so themes are an exact copy.
616 self.assertNotIn(first_new, idleConf.userCfg)
617 d.create_new(first_new)
618 eq(idleConf.GetSectionList('user', 'highlight'), [first_new])
619 eq(idleConf.GetThemeDict('default', 'IDLE Classic'),
620 idleConf.GetThemeDict('user', first_new))
621 eq(d.custom_name.get(), first_new)
622 self.assertFalse(d.theme_source.get()) # Use custom set.
623 eq(d.set_theme_type.called, 1)
624
625 # Test that changed targets are in new theme.
626 changes.add_option('highlight', first_new, 'hit-background', 'yellow')
627 self.assertNotIn(second_new, idleConf.userCfg)
628 d.create_new(second_new)
629 eq(idleConf.GetSectionList('user', 'highlight'), [first_new, second_new])
630 self.assertNotEqual(idleConf.GetThemeDict('user', first_new),
631 idleConf.GetThemeDict('user', second_new))
632 # Check that difference in themes was in `hit-background` from `changes`.
633 idleConf.SetOption('highlight', first_new, 'hit-background', 'yellow')
634 eq(idleConf.GetThemeDict('user', first_new),
635 idleConf.GetThemeDict('user', second_new))
636
637 def test_set_highlight_target(self):
638 eq = self.assertEqual
639 d = self.page
640 del d.set_highlight_target
641
642 # Target is cursor.
643 d.highlight_target.set('Cursor')
644 eq(d.fg_on.state(), ('disabled', 'selected'))
645 eq(d.bg_on.state(), ('disabled',))
646 self.assertTrue(d.fg_bg_toggle)
647 eq(d.set_color_sample.called, 1)
648
649 # Target is not cursor.
650 d.highlight_target.set('Comment')
651 eq(d.fg_on.state(), ('selected',))
652 eq(d.bg_on.state(), ())
653 self.assertTrue(d.fg_bg_toggle)
654 eq(d.set_color_sample.called, 2)
655
656 d.set_highlight_target = Func()
657
658 def test_set_color_sample_binding(self):
659 d = self.page
660 scs = d.set_color_sample
661
662 d.fg_on.invoke()
663 self.assertEqual(scs.called, 1)
664
665 d.bg_on.invoke()
666 self.assertEqual(scs.called, 2)
667
668 def test_set_color_sample(self):
669 d = self.page
670 del d.set_color_sample
671 d.highlight_target.set('Selected Text')
672 d.fg_bg_toggle.set(True)
673 d.set_color_sample()
674 self.assertEqual(
675 d.style.lookup(d.frame_color_set['style'], 'background'),
676 d.highlight_sample.tag_cget('hilite', 'foreground'))
677 d.set_color_sample = Func()
678
679 def test_paint_theme_sample(self):
680 eq = self.assertEqual
681 page = self.page
682 del page.paint_theme_sample # Delete masking mock.
683 hs_tag = page.highlight_sample.tag_cget
684 gh = idleConf.GetHighlight
685
686 # Create custom theme based on IDLE Dark.
687 page.theme_source.set(True)
688 page.builtin_name.set('IDLE Dark')
689 theme = 'IDLE Test'
690 page.create_new(theme)
691 page.set_color_sample.called = 0
692
693 # Base theme with nothing in `changes`.
694 page.paint_theme_sample()
695 new_console = {'foreground': 'blue',
696 'background': 'yellow',}
697 for key, value in new_console.items():
698 self.assertNotEqual(hs_tag('console', key), value)
699 eq(page.set_color_sample.called, 1)
700
701 # Apply changes.
702 for key, value in new_console.items():
703 changes.add_option('highlight', theme, 'console-'+key, value)
704 page.paint_theme_sample()
705 for key, value in new_console.items():
706 eq(hs_tag('console', key), value)
707 eq(page.set_color_sample.called, 2)
708
709 page.paint_theme_sample = Func()
710
711 def test_delete_custom(self):
712 eq = self.assertEqual
713 d = self.page
714 d.button_delete_custom.state(('!disabled',))
715 yesno = d.askyesno = Func()
716 dialog.deactivate_current_config = Func()
717 dialog.activate_config_changes = Func()
718
719 theme_name = 'spam theme'
720 idleConf.userCfg['highlight'].SetOption(theme_name, 'name', 'value')
721 highpage[theme_name] = {'option': 'True'}
722
723 theme_name2 = 'other theme'
724 idleConf.userCfg['highlight'].SetOption(theme_name2, 'name', 'value')
725 highpage[theme_name2] = {'option': 'False'}
726
727 # Force custom theme.
728 d.custom_theme_on.state(('!disabled',))
729 d.custom_theme_on.invoke()
730 d.custom_name.set(theme_name)
731
732 # Cancel deletion.
733 yesno.result = False
734 d.button_delete_custom.invoke()
735 eq(yesno.called, 1)
736 eq(highpage[theme_name], {'option': 'True'})
737 eq(idleConf.GetSectionList('user', 'highlight'), [theme_name, theme_name2])
738 eq(dialog.deactivate_current_config.called, 0)
739 eq(dialog.activate_config_changes.called, 0)
740 eq(d.set_theme_type.called, 0)
741
742 # Confirm deletion.
743 yesno.result = True
744 d.button_delete_custom.invoke()
745 eq(yesno.called, 2)
746 self.assertNotIn(theme_name, highpage)
747 eq(idleConf.GetSectionList('user', 'highlight'), [theme_name2])
748 eq(d.custom_theme_on.state(), ())
749 eq(d.custom_name.get(), theme_name2)
750 eq(dialog.deactivate_current_config.called, 1)
751 eq(dialog.activate_config_changes.called, 1)
752 eq(d.set_theme_type.called, 1)
753
754 # Confirm deletion of second theme - empties list.
755 d.custom_name.set(theme_name2)
756 yesno.result = True
757 d.button_delete_custom.invoke()
758 eq(yesno.called, 3)
759 self.assertNotIn(theme_name, highpage)
760 eq(idleConf.GetSectionList('user', 'highlight'), [])
761 eq(d.custom_theme_on.state(), ('disabled',))
762 eq(d.custom_name.get(), '- no custom themes -')
763 eq(dialog.deactivate_current_config.called, 2)
764 eq(dialog.activate_config_changes.called, 2)
765 eq(d.set_theme_type.called, 2)
766
767 del dialog.activate_config_changes, dialog.deactivate_current_config
768 del d.askyesno
769
770
771 class KeysPageTest(unittest.TestCase):
772 """Test that keys tab widgets enable users to make changes.
773
774 Test that widget actions set vars, that var changes add
775 options to changes and that key sets works correctly.
776 """
777
778 @classmethod
779 def setUpClass(cls):
780 page = cls.page = dialog.keyspage
781 dialog.note.select(page)
782 page.set_keys_type = Func()
783 page.load_keys_list = Func()
784
785 @classmethod
786 def tearDownClass(cls):
787 page = cls.page
788 del page.set_keys_type, page.load_keys_list
789
790 def setUp(self):
791 d = self.page
792 # The following is needed for test_load_key_cfg, _delete_custom_keys.
793 # This may indicate a defect in some test or function.
794 for section in idleConf.GetSectionList('user', 'keys'):
795 idleConf.userCfg['keys'].remove_section(section)
796 changes.clear()
797 d.set_keys_type.called = 0
798 d.load_keys_list.called = 0
799
800 def test_load_key_cfg(self):
801 tracers.detach()
802 d = self.page
803 eq = self.assertEqual
804
805 # Use builtin keyset with no user keysets created.
806 idleConf.CurrentKeys = mock.Mock(return_value='IDLE Classic OSX')
807 d.load_key_cfg()
808 self.assertTrue(d.keyset_source.get())
809 # builtinlist sets variable builtin_name to the CurrentKeys default.
810 eq(d.builtin_name.get(), 'IDLE Classic OSX')
811 eq(d.custom_name.get(), '- no custom keys -')
812 eq(d.custom_keyset_on.state(), ('disabled',))
813 eq(d.set_keys_type.called, 1)
814 eq(d.load_keys_list.called, 1)
815 eq(d.load_keys_list.args, ('IDLE Classic OSX', ))
816
817 # Builtin keyset with non-empty user keyset list.
818 idleConf.SetOption('keys', 'test1', 'option', 'value')
819 idleConf.SetOption('keys', 'test2', 'option2', 'value2')
820 d.load_key_cfg()
821 eq(d.builtin_name.get(), 'IDLE Classic OSX')
822 eq(d.custom_name.get(), 'test1')
823 eq(d.set_keys_type.called, 2)
824 eq(d.load_keys_list.called, 2)
825 eq(d.load_keys_list.args, ('IDLE Classic OSX', ))
826
827 # Use custom keyset.
828 idleConf.CurrentKeys = mock.Mock(return_value='test2')
829 idleConf.default_keys = mock.Mock(return_value='IDLE Modern Unix')
830 idleConf.SetOption('main', 'Keys', 'default', '0')
831 d.load_key_cfg()
832 self.assertFalse(d.keyset_source.get())
833 eq(d.builtin_name.get(), 'IDLE Modern Unix')
834 eq(d.custom_name.get(), 'test2')
835 eq(d.set_keys_type.called, 3)
836 eq(d.load_keys_list.called, 3)
837 eq(d.load_keys_list.args, ('test2', ))
838
839 del idleConf.CurrentKeys, idleConf.default_keys
840 tracers.attach()
841
842 def test_keyset_source(self):
843 eq = self.assertEqual
844 d = self.page
845 # Test these separately.
846 d.var_changed_builtin_name = Func()
847 d.var_changed_custom_name = Func()
848 # Builtin selected.
849 d.builtin_keyset_on.invoke()
850 eq(mainpage, {'Keys': {'default': 'True'}})
851 eq(d.var_changed_builtin_name.called, 1)
852 eq(d.var_changed_custom_name.called, 0)
853 changes.clear()
854
855 # Custom selected.
856 d.custom_keyset_on.state(('!disabled',))
857 d.custom_keyset_on.invoke()
858 self.assertEqual(mainpage, {'Keys': {'default': 'False'}})
859 eq(d.var_changed_builtin_name.called, 1)
860 eq(d.var_changed_custom_name.called, 1)
861 del d.var_changed_builtin_name, d.var_changed_custom_name
862
863 def test_builtin_name(self):
864 eq = self.assertEqual
865 d = self.page
866 idleConf.userCfg['main'].remove_section('Keys')
867 item_list = ['IDLE Classic Windows', 'IDLE Classic OSX',
868 'IDLE Modern UNIX']
869
870 # Not in old_keys, defaults name to first item.
871 d.builtinlist.SetMenu(item_list, 'IDLE Modern UNIX')
872 eq(mainpage, {'Keys': {'name': 'IDLE Classic Windows',
873 'name2': 'IDLE Modern UNIX'}})
874 eq(d.keys_message['text'], 'New key set, see Help')
875 eq(d.load_keys_list.called, 1)
876 eq(d.load_keys_list.args, ('IDLE Modern UNIX', ))
877
878 # Not in old keys - uses name2.
879 changes.clear()
880 idleConf.SetOption('main', 'Keys', 'name', 'IDLE Classic Unix')
881 d.builtinlist.SetMenu(item_list, 'IDLE Modern UNIX')
882 eq(mainpage, {'Keys': {'name2': 'IDLE Modern UNIX'}})
883 eq(d.keys_message['text'], 'New key set, see Help')
884 eq(d.load_keys_list.called, 2)
885 eq(d.load_keys_list.args, ('IDLE Modern UNIX', ))
886
887 # Builtin name in old_keys.
888 changes.clear()
889 d.builtinlist.SetMenu(item_list, 'IDLE Classic OSX')
890 eq(mainpage, {'Keys': {'name': 'IDLE Classic OSX', 'name2': ''}})
891 eq(d.keys_message['text'], '')
892 eq(d.load_keys_list.called, 3)
893 eq(d.load_keys_list.args, ('IDLE Classic OSX', ))
894
895 def test_custom_name(self):
896 d = self.page
897
898 # If no selections, doesn't get added.
899 d.customlist.SetMenu([], '- no custom keys -')
900 self.assertNotIn('Keys', mainpage)
901 self.assertEqual(d.load_keys_list.called, 0)
902
903 # Custom name selected.
904 changes.clear()
905 d.customlist.SetMenu(['a', 'b', 'c'], 'c')
906 self.assertEqual(mainpage, {'Keys': {'name': 'c'}})
907 self.assertEqual(d.load_keys_list.called, 1)
908
909 def test_keybinding(self):
910 idleConf.SetOption('extensions', 'ZzDummy', 'enable', 'True')
911 d = self.page
912 d.custom_name.set('my custom keys')
913 d.bindingslist.delete(0, 'end')
914 d.bindingslist.insert(0, 'copy')
915 d.bindingslist.insert(1, 'z-in')
916 d.bindingslist.selection_set(0)
917 d.bindingslist.selection_anchor(0)
918 # Core binding - adds to keys.
919 d.keybinding.set('<Key-F11>')
920 self.assertEqual(keyspage,
921 {'my custom keys': {'copy': '<Key-F11>'}})
922
923 # Not a core binding - adds to extensions.
924 d.bindingslist.selection_set(1)
925 d.bindingslist.selection_anchor(1)
926 d.keybinding.set('<Key-F11>')
927 self.assertEqual(extpage,
928 {'ZzDummy_cfgBindings': {'z-in': '<Key-F11>'}})
929
930 def test_set_keys_type(self):
931 eq = self.assertEqual
932 d = self.page
933 del d.set_keys_type
934
935 # Builtin keyset selected.
936 d.keyset_source.set(True)
937 d.set_keys_type()
938 eq(d.builtinlist['state'], NORMAL)
939 eq(d.customlist['state'], DISABLED)
940 eq(d.button_delete_custom_keys.state(), ('disabled',))
941
942 # Custom keyset selected.
943 d.keyset_source.set(False)
944 d.set_keys_type()
945 eq(d.builtinlist['state'], DISABLED)
946 eq(d.custom_keyset_on.state(), ('selected',))
947 eq(d.customlist['state'], NORMAL)
948 eq(d.button_delete_custom_keys.state(), ())
949 d.set_keys_type = Func()
950
951 def test_get_new_keys(self):
952 eq = self.assertEqual
953 d = self.page
954 orig_getkeysdialog = configdialog.GetKeysWindow
955 gkd = configdialog.GetKeysWindow = Func(return_self=True)
956 gnkn = d.get_new_keys_name = Func()
957
958 d.button_new_keys.state(('!disabled',))
959 d.bindingslist.delete(0, 'end')
960 d.bindingslist.insert(0, 'copy - <Control-Shift-Key-C>')
961 d.bindingslist.selection_set(0)
962 d.bindingslist.selection_anchor(0)
963 d.keybinding.set('Key-a')
964 d.keyset_source.set(True) # Default keyset.
965
966 # Default keyset; no change to binding.
967 gkd.result = ''
968 d.button_new_keys.invoke()
969 eq(d.bindingslist.get('anchor'), 'copy - <Control-Shift-Key-C>')
970 # Keybinding isn't changed when there isn't a change entered.
971 eq(d.keybinding.get(), 'Key-a')
972
973 # Default keyset; binding changed.
974 gkd.result = '<Key-F11>'
975 # No keyset name selected therefore binding not saved.
976 gnkn.result = ''
977 d.button_new_keys.invoke()
978 eq(gnkn.called, 1)
979 eq(d.bindingslist.get('anchor'), 'copy - <Control-Shift-Key-C>')
980 # Keyset name selected.
981 gnkn.result = 'My New Key Set'
982 d.button_new_keys.invoke()
983 eq(d.custom_name.get(), gnkn.result)
984 eq(d.bindingslist.get('anchor'), 'copy - <Key-F11>')
985 eq(d.keybinding.get(), '<Key-F11>')
986
987 # User keyset; binding changed.
988 d.keyset_source.set(False) # Custom keyset.
989 gnkn.called = 0
990 gkd.result = '<Key-p>'
991 d.button_new_keys.invoke()
992 eq(gnkn.called, 0)
993 eq(d.bindingslist.get('anchor'), 'copy - <Key-p>')
994 eq(d.keybinding.get(), '<Key-p>')
995
996 del d.get_new_keys_name
997 configdialog.GetKeysWindow = orig_getkeysdialog
998
999 def test_get_new_keys_name(self):
1000 orig_sectionname = configdialog.SectionName
1001 sn = configdialog.SectionName = Func(return_self=True)
1002 d = self.page
1003
1004 sn.result = 'New Keys'
1005 self.assertEqual(d.get_new_keys_name(''), 'New Keys')
1006
1007 configdialog.SectionName = orig_sectionname
1008
1009 def test_save_as_new_key_set(self):
1010 d = self.page
1011 gnkn = d.get_new_keys_name = Func()
1012 d.keyset_source.set(True)
1013
1014 # No name entered.
1015 gnkn.result = ''
1016 d.button_save_custom_keys.invoke()
1017
1018 # Name entered.
1019 gnkn.result = 'my new key set'
1020 gnkn.called = 0
1021 self.assertNotIn(gnkn.result, idleConf.userCfg['keys'])
1022 d.button_save_custom_keys.invoke()
1023 self.assertIn(gnkn.result, idleConf.userCfg['keys'])
1024
1025 del d.get_new_keys_name
1026
1027 def test_on_bindingslist_select(self):
1028 d = self.page
1029 b = d.bindingslist
1030 b.delete(0, 'end')
1031 b.insert(0, 'copy')
1032 b.insert(1, 'find')
1033 b.activate(0)
1034
1035 b.focus_force()
1036 b.see(1)
1037 b.update()
1038 x, y, dx, dy = b.bbox(1)
1039 x += dx // 2
1040 y += dy // 2
1041 b.event_generate('<Enter>', x=0, y=0)
1042 b.event_generate('<Motion>', x=x, y=y)
1043 b.event_generate('<Button-1>', x=x, y=y)
1044 b.event_generate('<ButtonRelease-1>', x=x, y=y)
1045 self.assertEqual(b.get('anchor'), 'find')
1046 self.assertEqual(d.button_new_keys.state(), ())
1047
1048 def test_create_new_key_set_and_save_new_key_set(self):
1049 eq = self.assertEqual
1050 d = self.page
1051
1052 # Use default as previously active keyset.
1053 d.keyset_source.set(True)
1054 d.builtin_name.set('IDLE Classic Windows')
1055 first_new = 'my new custom key set'
1056 second_new = 'my second custom keyset'
1057
1058 # No changes, so keysets are an exact copy.
1059 self.assertNotIn(first_new, idleConf.userCfg)
1060 d.create_new_key_set(first_new)
1061 eq(idleConf.GetSectionList('user', 'keys'), [first_new])
1062 eq(idleConf.GetKeySet('IDLE Classic Windows'),
1063 idleConf.GetKeySet(first_new))
1064 eq(d.custom_name.get(), first_new)
1065 self.assertFalse(d.keyset_source.get()) # Use custom set.
1066 eq(d.set_keys_type.called, 1)
1067
1068 # Test that changed keybindings are in new keyset.
1069 changes.add_option('keys', first_new, 'copy', '<Key-F11>')
1070 self.assertNotIn(second_new, idleConf.userCfg)
1071 d.create_new_key_set(second_new)
1072 eq(idleConf.GetSectionList('user', 'keys'), [first_new, second_new])
1073 self.assertNotEqual(idleConf.GetKeySet(first_new),
1074 idleConf.GetKeySet(second_new))
1075 # Check that difference in keysets was in option `copy` from `changes`.
1076 idleConf.SetOption('keys', first_new, 'copy', '<Key-F11>')
1077 eq(idleConf.GetKeySet(first_new), idleConf.GetKeySet(second_new))
1078
1079 def test_load_keys_list(self):
1080 eq = self.assertEqual
1081 d = self.page
1082 gks = idleConf.GetKeySet = Func()
1083 del d.load_keys_list
1084 b = d.bindingslist
1085
1086 b.delete(0, 'end')
1087 b.insert(0, '<<find>>')
1088 b.insert(1, '<<help>>')
1089 gks.result = {'<<copy>>': ['<Control-Key-c>', '<Control-Key-C>'],
1090 '<<force-open-completions>>': ['<Control-Key-space>'],
1091 '<<spam>>': ['<Key-F11>']}
1092 changes.add_option('keys', 'my keys', 'spam', '<Shift-Key-a>')
1093 expected = ('copy - <Control-Key-c> <Control-Key-C>',
1094 'force-open-completions - <Control-Key-space>',
1095 'spam - <Shift-Key-a>')
1096
1097 # No current selection.
1098 d.load_keys_list('my keys')
1099 eq(b.get(0, 'end'), expected)
1100 eq(b.get('anchor'), '')
1101 eq(b.curselection(), ())
1102
1103 # Check selection.
1104 b.selection_set(1)
1105 b.selection_anchor(1)
1106 d.load_keys_list('my keys')
1107 eq(b.get(0, 'end'), expected)
1108 eq(b.get('anchor'), 'force-open-completions - <Control-Key-space>')
1109 eq(b.curselection(), (1, ))
1110
1111 # Change selection.
1112 b.selection_set(2)
1113 b.selection_anchor(2)
1114 d.load_keys_list('my keys')
1115 eq(b.get(0, 'end'), expected)
1116 eq(b.get('anchor'), 'spam - <Shift-Key-a>')
1117 eq(b.curselection(), (2, ))
1118 d.load_keys_list = Func()
1119
1120 del idleConf.GetKeySet
1121
1122 def test_delete_custom_keys(self):
1123 eq = self.assertEqual
1124 d = self.page
1125 d.button_delete_custom_keys.state(('!disabled',))
1126 yesno = d.askyesno = Func()
1127 dialog.deactivate_current_config = Func()
1128 dialog.activate_config_changes = Func()
1129
1130 keyset_name = 'spam key set'
1131 idleConf.userCfg['keys'].SetOption(keyset_name, 'name', 'value')
1132 keyspage[keyset_name] = {'option': 'True'}
1133
1134 keyset_name2 = 'other key set'
1135 idleConf.userCfg['keys'].SetOption(keyset_name2, 'name', 'value')
1136 keyspage[keyset_name2] = {'option': 'False'}
1137
1138 # Force custom keyset.
1139 d.custom_keyset_on.state(('!disabled',))
1140 d.custom_keyset_on.invoke()
1141 d.custom_name.set(keyset_name)
1142
1143 # Cancel deletion.
1144 yesno.result = False
1145 d.button_delete_custom_keys.invoke()
1146 eq(yesno.called, 1)
1147 eq(keyspage[keyset_name], {'option': 'True'})
1148 eq(idleConf.GetSectionList('user', 'keys'), [keyset_name, keyset_name2])
1149 eq(dialog.deactivate_current_config.called, 0)
1150 eq(dialog.activate_config_changes.called, 0)
1151 eq(d.set_keys_type.called, 0)
1152
1153 # Confirm deletion.
1154 yesno.result = True
1155 d.button_delete_custom_keys.invoke()
1156 eq(yesno.called, 2)
1157 self.assertNotIn(keyset_name, keyspage)
1158 eq(idleConf.GetSectionList('user', 'keys'), [keyset_name2])
1159 eq(d.custom_keyset_on.state(), ())
1160 eq(d.custom_name.get(), keyset_name2)
1161 eq(dialog.deactivate_current_config.called, 1)
1162 eq(dialog.activate_config_changes.called, 1)
1163 eq(d.set_keys_type.called, 1)
1164
1165 # Confirm deletion of second keyset - empties list.
1166 d.custom_name.set(keyset_name2)
1167 yesno.result = True
1168 d.button_delete_custom_keys.invoke()
1169 eq(yesno.called, 3)
1170 self.assertNotIn(keyset_name, keyspage)
1171 eq(idleConf.GetSectionList('user', 'keys'), [])
1172 eq(d.custom_keyset_on.state(), ('disabled',))
1173 eq(d.custom_name.get(), '- no custom keys -')
1174 eq(dialog.deactivate_current_config.called, 2)
1175 eq(dialog.activate_config_changes.called, 2)
1176 eq(d.set_keys_type.called, 2)
1177
1178 del dialog.activate_config_changes, dialog.deactivate_current_config
1179 del d.askyesno
1180
1181
1182 class WinPageTest(unittest.TestCase):
1183 """Test that general tab widgets enable users to make changes.
1184
1185 Test that widget actions set vars, that var changes add
1186 options to changes.
1187 """
1188 @classmethod
1189 def setUpClass(cls):
1190 page = cls.page = dialog.winpage
1191 dialog.note.select(page)
1192 page.update()
1193
1194 def setUp(self):
1195 changes.clear()
1196
1197 def test_load_windows_cfg(self):
1198 # Set to wrong values, load, check right values.
1199 eq = self.assertEqual
1200 d = self.page
1201 d.startup_edit.set(1)
1202 d.win_width.set(1)
1203 d.win_height.set(1)
1204 d.load_windows_cfg()
1205 eq(d.startup_edit.get(), 0)
1206 eq(d.win_width.get(), '80')
1207 eq(d.win_height.get(), '40')
1208
1209 def test_startup(self):
1210 d = self.page
1211 d.startup_editor_on.invoke()
1212 self.assertEqual(mainpage,
1213 {'General': {'editor-on-startup': '1'}})
1214 changes.clear()
1215 d.startup_shell_on.invoke()
1216 self.assertEqual(mainpage,
1217 {'General': {'editor-on-startup': '0'}})
1218
1219 def test_editor_size(self):
1220 d = self.page
1221 d.win_height_int.delete(0, 'end')
1222 d.win_height_int.insert(0, '11')
1223 self.assertEqual(mainpage, {'EditorWindow': {'height': '11'}})
1224 changes.clear()
1225 d.win_width_int.delete(0, 'end')
1226 d.win_width_int.insert(0, '11')
1227 self.assertEqual(mainpage, {'EditorWindow': {'width': '11'}})
1228
1229 def test_indent_spaces(self):
1230 d = self.page
1231 d.indent_chooser.set(6)
1232 self.assertEqual(d.indent_spaces.get(), '6')
1233 self.assertEqual(mainpage, {'Indent': {'num-spaces': '6'}})
1234
1235 def test_cursor_blink(self):
1236 self.page.cursor_blink_bool.invoke()
1237 self.assertEqual(mainpage, {'EditorWindow': {'cursor-blink': 'False'}})
1238
1239 def test_autocomplete_wait(self):
1240 self.page.auto_wait_int.delete(0, 'end')
1241 self.page.auto_wait_int.insert(0, '11')
1242 self.assertEqual(extpage, {'AutoComplete': {'popupwait': '11'}})
1243
1244 def test_parenmatch(self):
1245 d = self.page
1246 eq = self.assertEqual
1247 d.paren_style_type['menu'].invoke(0)
1248 eq(extpage, {'ParenMatch': {'style': 'opener'}})
1249 changes.clear()
1250 d.paren_flash_time.delete(0, 'end')
1251 d.paren_flash_time.insert(0, '11')
1252 eq(extpage, {'ParenMatch': {'flash-delay': '11'}})
1253 changes.clear()
1254 d.bell_on.invoke()
1255 eq(extpage, {'ParenMatch': {'bell': 'False'}})
1256
1257 def test_paragraph(self):
1258 self.page.format_width_int.delete(0, 'end')
1259 self.page.format_width_int.insert(0, '11')
1260 self.assertEqual(extpage, {'FormatParagraph': {'max-width': '11'}})
1261
1262
1263 class ShedPageTest(unittest.TestCase):
1264 """Test that shed tab widgets enable users to make changes.
1265
1266 Test that widget actions set vars, that var changes add
1267 options to changes.
1268 """
1269 @classmethod
1270 def setUpClass(cls):
1271 page = cls.page = dialog.shedpage
1272 dialog.note.select(page)
1273 page.update()
1274
1275 def setUp(self):
1276 changes.clear()
1277
1278 def test_load_shelled_cfg(self):
1279 # Set to wrong values, load, check right values.
1280 eq = self.assertEqual
1281 d = self.page
1282 d.autosave.set(1)
1283 d.load_shelled_cfg()
1284 eq(d.autosave.get(), 0)
1285
1286 def test_autosave(self):
1287 d = self.page
1288 d.save_auto_on.invoke()
1289 self.assertEqual(mainpage, {'General': {'autosave': '1'}})
1290 d.save_ask_on.invoke()
1291 self.assertEqual(mainpage, {'General': {'autosave': '0'}})
1292
1293 def test_context(self):
1294 self.page.context_int.delete(0, 'end')
1295 self.page.context_int.insert(0, '1')
1296 self.assertEqual(extpage, {'CodeContext': {'maxlines': '1'}})
1297
1298
1299 #unittest.skip("Nothing here yet TODO")
1300 class ExtPageTest(unittest.TestCase):
1301 """Test that the help source list works correctly."""
1302 @classmethod
1303 def setUpClass(cls):
1304 page = dialog.extpage
1305 dialog.note.select(page)
1306
1307
1308 class HelpSourceTest(unittest.TestCase):
1309 """Test that the help source list works correctly."""
1310 @classmethod
1311 def setUpClass(cls):
1312 page = dialog.extpage
1313 dialog.note.select(page)
1314 frame = cls.frame = page.frame_help
1315 frame.set = frame.set_add_delete_state = Func()
1316 frame.upc = frame.update_help_changes = Func()
1317 frame.update()
1318
1319 @classmethod
1320 def tearDownClass(cls):
1321 frame = cls.frame
1322 del frame.set, frame.set_add_delete_state
1323 del frame.upc, frame.update_help_changes
1324 frame.helplist.delete(0, 'end')
1325 frame.user_helplist.clear()
1326
1327 def setUp(self):
1328 changes.clear()
1329
1330 def test_load_helplist(self):
1331 eq = self.assertEqual
1332 fr = self.frame
1333 fr.helplist.insert('end', 'bad')
1334 fr.user_helplist = ['bad', 'worse']
1335 idleConf.SetOption('main', 'HelpFiles', '1', 'name;file')
1336 fr.load_helplist()
1337 eq(fr.helplist.get(0, 'end'), ('name',))
1338 eq(fr.user_helplist, [('name', 'file', '1')])
1339
1340 def test_source_selected(self):
1341 fr = self.frame
1342 fr.set = fr.set_add_delete_state
1343 fr.upc = fr.update_help_changes
1344 helplist = fr.helplist
1345 dex = 'end'
1346 helplist.insert(dex, 'source')
1347 helplist.activate(dex)
1348
1349 helplist.focus_force()
1350 helplist.see(dex)
1351 helplist.update()
1352 x, y, dx, dy = helplist.bbox(dex)
1353 x += dx // 2
1354 y += dy // 2
1355 fr.set.called = fr.upc.called = 0
1356 helplist.event_generate('<Enter>', x=0, y=0)
1357 helplist.event_generate('<Motion>', x=x, y=y)
1358 helplist.event_generate('<Button-1>', x=x, y=y)
1359 helplist.event_generate('<ButtonRelease-1>', x=x, y=y)
1360 self.assertEqual(helplist.get('anchor'), 'source')
1361 self.assertTrue(fr.set.called)
1362 self.assertFalse(fr.upc.called)
1363
1364 def test_set_add_delete_state(self):
1365 # Call with 0 items, 1 unselected item, 1 selected item.
1366 eq = self.assertEqual
1367 fr = self.frame
1368 del fr.set_add_delete_state # Unmask method.
1369 sad = fr.set_add_delete_state
1370 h = fr.helplist
1371
1372 h.delete(0, 'end')
1373 sad()
1374 eq(fr.button_helplist_edit.state(), ('disabled',))
1375 eq(fr.button_helplist_remove.state(), ('disabled',))
1376
1377 h.insert(0, 'source')
1378 sad()
1379 eq(fr.button_helplist_edit.state(), ('disabled',))
1380 eq(fr.button_helplist_remove.state(), ('disabled',))
1381
1382 h.selection_set(0)
1383 sad()
1384 eq(fr.button_helplist_edit.state(), ())
1385 eq(fr.button_helplist_remove.state(), ())
1386 fr.set_add_delete_state = Func() # Mask method.
1387
1388 def test_helplist_item_add(self):
1389 # Call without and twice with HelpSource result.
1390 # Double call enables check on order.
1391 eq = self.assertEqual
1392 orig_helpsource = configdialog.HelpSource
1393 hs = configdialog.HelpSource = Func(return_self=True)
1394 fr = self.frame
1395 fr.helplist.delete(0, 'end')
1396 fr.user_helplist.clear()
1397 fr.set.called = fr.upc.called = 0
1398
1399 hs.result = ''
1400 fr.helplist_item_add()
1401 self.assertTrue(list(fr.helplist.get(0, 'end')) ==
1402 fr.user_helplist == [])
1403 self.assertFalse(fr.upc.called)
1404
1405 hs.result = ('name1', 'file1')
1406 fr.helplist_item_add()
1407 hs.result = ('name2', 'file2')
1408 fr.helplist_item_add()
1409 eq(fr.helplist.get(0, 'end'), ('name1', 'name2'))
1410 eq(fr.user_helplist, [('name1', 'file1'), ('name2', 'file2')])
1411 eq(fr.upc.called, 2)
1412 self.assertFalse(fr.set.called)
1413
1414 configdialog.HelpSource = orig_helpsource
1415
1416 def test_helplist_item_edit(self):
1417 # Call without and with HelpSource change.
1418 eq = self.assertEqual
1419 orig_helpsource = configdialog.HelpSource
1420 hs = configdialog.HelpSource = Func(return_self=True)
1421 fr = self.frame
1422 fr.helplist.delete(0, 'end')
1423 fr.helplist.insert(0, 'name1')
1424 fr.helplist.selection_set(0)
1425 fr.helplist.selection_anchor(0)
1426 fr.user_helplist.clear()
1427 fr.user_helplist.append(('name1', 'file1'))
1428 fr.set.called = fr.upc.called = 0
1429
1430 hs.result = ''
1431 fr.helplist_item_edit()
1432 hs.result = ('name1', 'file1')
1433 fr.helplist_item_edit()
1434 eq(fr.helplist.get(0, 'end'), ('name1',))
1435 eq(fr.user_helplist, [('name1', 'file1')])
1436 self.assertFalse(fr.upc.called)
1437
1438 hs.result = ('name2', 'file2')
1439 fr.helplist_item_edit()
1440 eq(fr.helplist.get(0, 'end'), ('name2',))
1441 eq(fr.user_helplist, [('name2', 'file2')])
1442 self.assertTrue(fr.upc.called == fr.set.called == 1)
1443
1444 configdialog.HelpSource = orig_helpsource
1445
1446 def test_helplist_item_remove(self):
1447 eq = self.assertEqual
1448 fr = self.frame
1449 fr.helplist.delete(0, 'end')
1450 fr.helplist.insert(0, 'name1')
1451 fr.helplist.selection_set(0)
1452 fr.helplist.selection_anchor(0)
1453 fr.user_helplist.clear()
1454 fr.user_helplist.append(('name1', 'file1'))
1455 fr.set.called = fr.upc.called = 0
1456
1457 fr.helplist_item_remove()
1458 eq(fr.helplist.get(0, 'end'), ())
1459 eq(fr.user_helplist, [])
1460 self.assertTrue(fr.upc.called == fr.set.called == 1)
1461
1462 def test_update_help_changes(self):
1463 fr = self.frame
1464 del fr.update_help_changes
1465 fr.user_helplist.clear()
1466 fr.user_helplist.append(('name1', 'file1'))
1467 fr.user_helplist.append(('name2', 'file2'))
1468
1469 fr.update_help_changes()
1470 self.assertEqual(mainpage['HelpFiles'],
1471 {'1': 'name1;file1', '2': 'name2;file2'})
1472 fr.update_help_changes = Func()
1473
1474
1475 class VarTraceTest(unittest.TestCase):
1476
1477 @classmethod
1478 def setUpClass(cls):
1479 cls.tracers = configdialog.VarTrace()
1480 cls.iv = IntVar(root)
1481 cls.bv = BooleanVar(root)
1482
1483 @classmethod
1484 def tearDownClass(cls):
1485 del cls.tracers, cls.iv, cls.bv
1486
1487 def setUp(self):
1488 self.tracers.clear()
1489 self.called = 0
1490
1491 def var_changed_increment(self, *params):
1492 self.called += 13
1493
1494 def var_changed_boolean(self, *params):
1495 pass
1496
1497 def test_init(self):
1498 tr = self.tracers
1499 tr.__init__()
1500 self.assertEqual(tr.untraced, [])
1501 self.assertEqual(tr.traced, [])
1502
1503 def test_clear(self):
1504 tr = self.tracers
1505 tr.untraced.append(0)
1506 tr.traced.append(1)
1507 tr.clear()
1508 self.assertEqual(tr.untraced, [])
1509 self.assertEqual(tr.traced, [])
1510
1511 def test_add(self):
1512 tr = self.tracers
1513 func = Func()
1514 cb = tr.make_callback = mock.Mock(return_value=func)
1515
1516 iv = tr.add(self.iv, self.var_changed_increment)
1517 self.assertIs(iv, self.iv)
1518 bv = tr.add(self.bv, self.var_changed_boolean)
1519 self.assertIs(bv, self.bv)
1520
1521 sv = StringVar(root)
1522 sv2 = tr.add(sv, ('main', 'section', 'option'))
1523 self.assertIs(sv2, sv)
1524 cb.assert_called_once()
1525 cb.assert_called_with(sv, ('main', 'section', 'option'))
1526
1527 expected = [(iv, self.var_changed_increment),
1528 (bv, self.var_changed_boolean),
1529 (sv, func)]
1530 self.assertEqual(tr.traced, [])
1531 self.assertEqual(tr.untraced, expected)
1532
1533 del tr.make_callback
1534
1535 def test_make_callback(self):
1536 cb = self.tracers.make_callback(self.iv, ('main', 'section', 'option'))
1537 self.assertTrue(callable(cb))
1538 self.iv.set(42)
1539 # Not attached, so set didn't invoke the callback.
1540 self.assertNotIn('section', changes['main'])
1541 # Invoke callback manually.
1542 cb()
1543 self.assertIn('section', changes['main'])
1544 self.assertEqual(changes['main']['section']['option'], '42')
1545 changes.clear()
1546
1547 def test_attach_detach(self):
1548 tr = self.tracers
1549 iv = tr.add(self.iv, self.var_changed_increment)
1550 bv = tr.add(self.bv, self.var_changed_boolean)
1551 expected = [(iv, self.var_changed_increment),
1552 (bv, self.var_changed_boolean)]
1553
1554 # Attach callbacks and test call increment.
1555 tr.attach()
1556 self.assertEqual(tr.untraced, [])
1557 self.assertCountEqual(tr.traced, expected)
1558 iv.set(1)
1559 self.assertEqual(iv.get(), 1)
1560 self.assertEqual(self.called, 13)
1561
1562 # Check that only one callback is attached to a variable.
1563 # If more than one callback were attached, then var_changed_increment
1564 # would be called twice and the counter would be 2.
1565 self.called = 0
1566 tr.attach()
1567 iv.set(1)
1568 self.assertEqual(self.called, 13)
1569
1570 # Detach callbacks.
1571 self.called = 0
1572 tr.detach()
1573 self.assertEqual(tr.traced, [])
1574 self.assertCountEqual(tr.untraced, expected)
1575 iv.set(1)
1576 self.assertEqual(self.called, 0)
1577
1578
1579 if __name__ == '__main__':
1580 unittest.main(verbosity=2)