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