| 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) |