Coverage for idle_test/test_config.py: 93%

1"""Test config, coverage 93%. 

2(100% for IdleConfParser, IdleUserConfParser*, ConfigChanges). 

3* Exception is OSError clause in Save method. 

4Much of IdleConf is also exercised by ConfigDialog and test_configdialog. 

5""" 

6from idlelib import config (empty)

7import sys (empty)

8import os (empty)

9import tempfile (empty)

10from test.support import captured_stderr, findfile (empty)

11import unittest (empty)

12from unittest import mock (empty)

13import idlelib (empty)

14from idlelib.idle_test.mock_idle import Func (empty)

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 

21idleConf = config.idleConf (empty)

22usercfg = idleConf.userCfg (empty)

23testcfg = {} (empty)

24usermain = testcfg['main'] = config.IdleUserConfParser('') (empty)

25userhigh = testcfg['highlight'] = config.IdleUserConfParser('') (empty)

26userkeys = testcfg['keys'] = config.IdleUserConfParser('') (empty)

27userextn = testcfg['extensions'] = config.IdleUserConfParser('') (empty)

28 

29def setUpModule(): (empty)

30 idleConf.userCfg = testcfg (empty)

31 idlelib.testing = True (empty)

32 

33def tearDownModule(): (empty)

34 idleConf.userCfg = usercfg (empty)

35 idlelib.testing = False (empty)

36 

37 

38class IdleConfParserTest(unittest.TestCase): (empty)

39 """Test that IdleConfParser works""" 

40 

41 config = """ (empty)

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): (empty)

54 parser = config.IdleConfParser('') 1 ctx1j

55 parser.read_string(self.config) 1 ctx1j

56 eq = self.assertEqual 1 ctx1j

57 

58 # Test with type argument. 

59 self.assertIs(parser.Get('one', 'one', type='bool'), False) 1 ctx1j

60 self.assertIs(parser.Get('one', 'two', type='bool'), True) 1 ctx1j

61 eq(parser.Get('one', 'three', type='int'), 10) 1 ctx1j

62 eq(parser.Get('two', 'one'), 'a string') 1 ctx1j

63 self.assertIs(parser.Get('two', 'two', type='bool'), True) 1 ctx1j

64 self.assertIs(parser.Get('two', 'three', type='bool'), False) 1 ctx1j

65 

66 # Test without type should fallback to string. 

67 eq(parser.Get('two', 'two'), 'true') 1 ctx1j

68 eq(parser.Get('two', 'three'), 'false') 1 ctx1j

69 

70 # If option not exist, should return None, or default. 

71 self.assertIsNone(parser.Get('not', 'exist')) 1 ctx1j

72 eq(parser.Get('not', 'exist', default='DEFAULT'), 'DEFAULT') 1 ctx1j

73 

74 def test_get_option_list(self): (empty)

75 parser = config.IdleConfParser('') 1 ctx1P

76 parser.read_string(self.config) 1 ctx1P

77 get_list = parser.GetOptionList 1 ctx1P

78 self.assertCountEqual(get_list('one'), ['one', 'two', 'three']) 1 ctx1P

79 self.assertCountEqual(get_list('two'), ['one', 'two', 'three']) 1 ctx1P

80 self.assertEqual(get_list('not exist'), []) 1 ctx1P

81 

82 def test_load_nothing(self): (empty)

83 parser = config.IdleConfParser('') 1 ctx1U

84 parser.Load() 1 ctx1U

85 self.assertEqual(parser.sections(), []) 1 ctx1U

86 

87 def test_load_file(self): (empty)

88 # Borrow test/cfgparser.1 from test_configparser. 

89 config_path = findfile('cfgparser.1') 1 ctx1S

90 parser = config.IdleConfParser(config_path) 1 ctx1S

91 parser.Load() 1 ctx1S

92 

93 self.assertEqual(parser.Get('Foo Bar', 'foo'), 'newbar') 1 ctx1S

94 self.assertEqual(parser.GetOptionList('Foo Bar'), ['foo']) 1 ctx1S

95 

96 

97class IdleUserConfParserTest(unittest.TestCase): (empty)

98 """Test that IdleUserConfParser works""" 

99 

100 def new_parser(self, path=''): (empty)

101 return config.IdleUserConfParser(path) 6 ctx1KvFLow

102 

103 def test_set_option(self): (empty)

104 parser = self.new_parser() 1 ctx1w

105 parser.add_section('Foo') 1 ctx1w

106 # Setting new option in existing section should return True. 

107 self.assertTrue(parser.SetOption('Foo', 'bar', 'true')) 1 ctx1w

108 # Setting existing option with same value should return False. 

109 self.assertFalse(parser.SetOption('Foo', 'bar', 'true')) 1 ctx1w

110 # Setting exiting option with new value should return True. 

111 self.assertTrue(parser.SetOption('Foo', 'bar', 'false')) 1 ctx1w

112 self.assertEqual(parser.Get('Foo', 'bar'), 'false') 1 ctx1w

113 

114 # Setting option in new section should create section and return True. 

115 self.assertTrue(parser.SetOption('Bar', 'bar', 'true')) 1 ctx1w

116 self.assertCountEqual(parser.sections(), ['Bar', 'Foo']) 1 ctx1w

117 self.assertEqual(parser.Get('Bar', 'bar'), 'true') 1 ctx1w

118 

119 def test_remove_option(self): (empty)

120 parser = self.new_parser() 1 ctx1L

121 parser.AddSection('Foo') 1 ctx1L

122 parser.SetOption('Foo', 'bar', 'true') 1 ctx1L

123 

124 self.assertTrue(parser.RemoveOption('Foo', 'bar')) 1 ctx1L

125 self.assertFalse(parser.RemoveOption('Foo', 'bar')) 1 ctx1L

126 self.assertFalse(parser.RemoveOption('Not', 'Exist')) 1 ctx1L

127 

128 def test_add_section(self): (empty)

129 parser = self.new_parser() 1 ctx1K

130 self.assertEqual(parser.sections(), []) 1 ctx1K

131 

132 # Should not add duplicate section. 

133 # Configparser raises DuplicateError, IdleParser not. 

134 parser.AddSection('Foo') 1 ctx1K

135 parser.AddSection('Foo') 1 ctx1K

136 parser.AddSection('Bar') 1 ctx1K

137 self.assertCountEqual(parser.sections(), ['Bar', 'Foo']) 1 ctx1K

138 

139 def test_remove_empty_sections(self): (empty)

140 parser = self.new_parser() 1 ctx1F

141 

142 parser.AddSection('Foo') 1 ctx1F

143 parser.AddSection('Bar') 1 ctx1F

144 parser.SetOption('Idle', 'name', 'val') 1 ctx1F

145 self.assertCountEqual(parser.sections(), ['Bar', 'Foo', 'Idle']) 1 ctx1F

146 parser.RemoveEmptySections() 1 ctx1F

147 self.assertEqual(parser.sections(), ['Idle']) 1 ctx1F

148 

149 def test_is_empty(self): (empty)

150 parser = self.new_parser() 1 ctx1v

151 

152 parser.AddSection('Foo') 1 ctx1v

153 parser.AddSection('Bar') 1 ctx1v

154 self.assertTrue(parser.IsEmpty()) 1 ctx1v

155 self.assertEqual(parser.sections(), []) 1 ctx1v

156 

157 parser.SetOption('Foo', 'bar', 'false') 1 ctx1v

158 parser.AddSection('Bar') 1 ctx1v

159 self.assertFalse(parser.IsEmpty()) 1 ctx1v

160 self.assertCountEqual(parser.sections(), ['Foo']) 1 ctx1v

161 

162 def test_save(self): (empty)

163 with tempfile.TemporaryDirectory() as tdir: 1 ctx1o

164 path = os.path.join(tdir, 'test.cfg') 1 ctx1o

165 parser = self.new_parser(path) 1 ctx1o

166 parser.AddSection('Foo') 1 ctx1o

167 parser.SetOption('Foo', 'bar', 'true') 1 ctx1o

168 

169 # Should save to path when config is not empty. 

170 self.assertFalse(os.path.exists(path)) 1 ctx1o

171 parser.Save() 1 ctx1o

172 self.assertTrue(os.path.exists(path)) 1 ctx1o

173 

174 # Should remove the file from disk when config is empty. 

175 parser.remove_section('Foo') 1 ctx1o

176 parser.Save() 1 ctx1o

177 self.assertFalse(os.path.exists(path)) 1 ctx1o

178 

179 

180class IdleConfTest(unittest.TestCase): (empty)

181 """Test for idleConf""" 

182 

183 @classmethod (empty)

184 def setUpClass(cls): (empty)

185 cls.config_string = {} (empty)

186 

187 conf = config.IdleConf(_utest=True) (empty)

188 if __name__ != '__main__': 188 ↛ 191line 188 didn't jump to line 191, because the condition on line 188 was never false(empty)

189 idle_dir = os.path.dirname(__file__) (empty)

190 else: 

191 idle_dir = os.path.abspath(sys.path[0]) 

192 for ctype in conf.config_types: (empty)

193 config_path = os.path.join(idle_dir, '../config-%s.def' % ctype) (empty)

194 with open(config_path, 'r') as f: (empty)

195 cls.config_string[ctype] = f.read() (empty)

196 

197 cls.orig_warn = config._warn (empty)

198 config._warn = Func() (empty)

199 

200 @classmethod (empty)

201 def tearDownClass(cls): (empty)

202 config._warn = cls.orig_warn (empty)

203 

204 def new_config(self, _utest=False): (empty)

205 return config.IdleConf(_utest=_utest) 4 ctx1cxks

206 

207 def mock_config(self): (empty)

208 """Return a mocked idleConf 

209 

210 Both default and user config used the same config-*.def 

211 """ 

212 conf = config.IdleConf(_utest=True) 16 ctx1BbdpyqgelfitrCuz

213 for ctype in conf.config_types: 16 ctx1BbdpyqgelfitrCuz

214 conf.defaultCfg[ctype] = config.IdleConfParser('') 16 ctx1BbdpyqgelfitrCuz

215 conf.defaultCfg[ctype].read_string(self.config_string[ctype]) 16 ctx1BbdpyqgelfitrCuz

216 conf.userCfg[ctype] = config.IdleUserConfParser('') 16 ctx1BbdpyqgelfitrCuz

217 conf.userCfg[ctype].read_string(self.config_string[ctype]) 16 ctx1BbdpyqgelfitrCuz

218 

219 return conf 16 ctx1BbdpyqgelfitrCuz

220 

221 @unittest.skipIf(sys.platform.startswith('win'), 'this is test for unix system') (empty)

222 def test_get_user_cfg_dir_unix(self): (empty)

223 # Test to get user config directory under unix. 

224 conf = self.new_config(_utest=True) 1 ctx1k

225 

226 # Check normal way should success 

227 with mock.patch('os.path.expanduser', return_value='/home/foo'): 1 ctx1k

228 with mock.patch('os.path.exists', return_value=True): 1 ctx1k

229 self.assertEqual(conf.GetUserCfgDir(), '/home/foo/.idlerc') 1 ctx1k

230 

231 # Check os.getcwd should success 

232 with mock.patch('os.path.expanduser', return_value='~'): 1 ctx1k

233 with mock.patch('os.getcwd', return_value='/home/foo/cpython'): 1 ctx1k

234 with mock.patch('os.mkdir'): 1 ctx1k

235 self.assertEqual(conf.GetUserCfgDir(), 1 ctx1k

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'): 1 ctx1k

240 with self.assertRaises(SystemExit): 1 ctx1k

241 with self.assertRaises(FileNotFoundError): 1 ctx1k

242 conf.GetUserCfgDir() 1 ctx1k

243 

244 @unittest.skipIf(not sys.platform.startswith('win'), 'this is test for Windows system') (empty)

245 def test_get_user_cfg_dir_windows(self): (empty)

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): (empty)

268 conf = self.new_config(_utest=True) 1 ctx1c

269 

270 # Mock out idle_dir 

271 idle_dir = '/home/foo' 1 ctx1c

272 with mock.patch.dict({'__name__': '__foo__'}): 1 ctx1c

273 with mock.patch('os.path.dirname', return_value=idle_dir): 1 ctx1c

274 conf.CreateConfigHandlers() 1 ctx1c

275 

276 # Check keys are equal 

277 self.assertCountEqual(conf.defaultCfg.keys(), conf.config_types) 1 ctx1c

278 self.assertCountEqual(conf.userCfg.keys(), conf.config_types) 1 ctx1c

279 

280 # Check conf parser are correct type 

281 for default_parser in conf.defaultCfg.values(): 1 ctx1c

282 self.assertIsInstance(default_parser, config.IdleConfParser) 1 ctx1c

283 for user_parser in conf.userCfg.values(): 1 ctx1c

284 self.assertIsInstance(user_parser, config.IdleUserConfParser) 1 ctx1c

285 

286 # Check config path are correct 

287 for cfg_type, parser in conf.defaultCfg.items(): 1 ctx1c

288 self.assertEqual(parser.file, 1 ctx1c

289 os.path.join(idle_dir, f'config-{cfg_type}.def')) 

290 for cfg_type, parser in conf.userCfg.items(): 1 ctx1c

291 self.assertEqual(parser.file, 1 ctx1c

292 os.path.join(conf.userdir or '#', f'config-{cfg_type}.cfg')) 

293 

294 def test_load_cfg_files(self): (empty)

295 conf = self.new_config(_utest=True) 1 ctx1s

296 

297 # Borrow test/cfgparser.1 from test_configparser. 

298 config_path = findfile('cfgparser.1') 1 ctx1s

299 conf.defaultCfg['foo'] = config.IdleConfParser(config_path) 1 ctx1s

300 conf.userCfg['foo'] = config.IdleUserConfParser(config_path) 1 ctx1s

301 

302 # Load all config from path 

303 conf.LoadCfgFiles() 1 ctx1s

304 

305 eq = self.assertEqual 1 ctx1s

306 

307 # Check defaultCfg is loaded 

308 eq(conf.defaultCfg['foo'].Get('Foo Bar', 'foo'), 'newbar') 1 ctx1s

309 eq(conf.defaultCfg['foo'].GetOptionList('Foo Bar'), ['foo']) 1 ctx1s

310 

311 # Check userCfg is loaded 

312 eq(conf.userCfg['foo'].Get('Foo Bar', 'foo'), 'newbar') 1 ctx1s

313 eq(conf.userCfg['foo'].GetOptionList('Foo Bar'), ['foo']) 1 ctx1s

314 

315 def test_save_user_cfg_files(self): (empty)

316 conf = self.mock_config() 1 ctx1u

317 

318 with mock.patch('idlelib.config.IdleUserConfParser.Save') as m: 1 ctx1u

319 conf.SaveUserCfgFiles() 1 ctx1u

320 self.assertEqual(m.call_count, len(conf.userCfg)) 1 ctx1u

321 

322 def test_get_option(self): (empty)

323 conf = self.mock_config() 1 ctx1f

324 

325 eq = self.assertEqual 1 ctx1f

326 eq(conf.GetOption('main', 'EditorWindow', 'width'), '80') 1 ctx1f

327 eq(conf.GetOption('main', 'EditorWindow', 'width', type='int'), 80) 1 ctx1f

328 with mock.patch('idlelib.config._warn') as _warn: 1 ctx1f

329 eq(conf.GetOption('main', 'EditorWindow', 'font', type='int'), None) 1 ctx1f

330 eq(conf.GetOption('main', 'EditorWindow', 'NotExists'), None) 1 ctx1f

331 eq(conf.GetOption('main', 'EditorWindow', 'NotExists', default='NE'), 'NE') 1 ctx1f

332 eq(_warn.call_count, 4) 1 ctx1f

333 

334 def test_set_option(self): (empty)

335 conf = self.mock_config() 1 ctx1z

336 

337 conf.SetOption('main', 'Foo', 'bar', 'newbar') 1 ctx1z

338 self.assertEqual(conf.GetOption('main', 'Foo', 'bar'), 'newbar') 1 ctx1z

339 

340 def test_get_section_list(self): (empty)

341 conf = self.mock_config() 1 ctx1i

342 

343 self.assertCountEqual( 1 ctx1i

344 conf.GetSectionList('default', 'main'), 

345 ['General', 'EditorWindow', 'PyShell', 'Indent', 'Theme', 

346 'Keys', 'History', 'HelpFiles']) 

347 self.assertCountEqual( 1 ctx1i

348 conf.GetSectionList('user', 'main'), 

349 ['General', 'EditorWindow', 'PyShell', 'Indent', 'Theme', 

350 'Keys', 'History', 'HelpFiles']) 

351 

352 with self.assertRaises(config.InvalidConfigSet): 1 ctx1i

353 conf.GetSectionList('foobar', 'main') 1 ctx1i

354 with self.assertRaises(config.InvalidConfigType): 1 ctx1i

355 conf.GetSectionList('default', 'notexists') 1 ctx1i

356 

357 def test_get_highlight(self): (empty)

358 conf = self.mock_config() 1 ctx1g

359 

360 eq = self.assertEqual 1 ctx1g

361 eq(conf.GetHighlight('IDLE Classic', 'normal'), {'foreground': '#000000', 1 ctx1g

362 'background': '#ffffff'}) 

363 

364 # Test cursor (this background should be normal-background) 

365 eq(conf.GetHighlight('IDLE Classic', 'cursor'), {'foreground': 'black', 1 ctx1g

366 'background': '#ffffff'}) 

367 

368 # Test get user themes 

369 conf.SetOption('highlight', 'Foobar', 'normal-foreground', '#747474') 1 ctx1g

370 conf.SetOption('highlight', 'Foobar', 'normal-background', '#171717') 1 ctx1g

371 with mock.patch('idlelib.config._warn'): 1 ctx1g

372 eq(conf.GetHighlight('Foobar', 'normal'), {'foreground': '#747474', 1 ctx1g

373 'background': '#171717'}) 

374 

375 def test_get_theme_dict(self): (empty)

376 # TODO: finish. 

377 conf = self.mock_config() 1 ctx1t

378 

379 # These two should be the same 

380 self.assertEqual( 1 ctx1t

381 conf.GetThemeDict('default', 'IDLE Classic'), 

382 conf.GetThemeDict('user', 'IDLE Classic')) 

383 

384 with self.assertRaises(config.InvalidTheme): 1 ctx1t

385 conf.GetThemeDict('bad', 'IDLE Classic') 1 ctx1t

386 

387 def test_get_current_theme_and_keys(self): (empty)

388 conf = self.mock_config() 1 ctx1y

389 

390 self.assertEqual(conf.CurrentTheme(), conf.current_colors_and_keys('Theme')) 1 ctx1y

391 self.assertEqual(conf.CurrentKeys(), conf.current_colors_and_keys('Keys')) 1 ctx1y

392 

393 def test_current_colors_and_keys(self): (empty)

394 conf = self.mock_config() 1 ctx1B

395 

396 self.assertEqual(conf.current_colors_and_keys('Theme'), 'IDLE Classic') 1 ctx1B

397 

398 def test_default_keys(self): (empty)

399 current_platform = sys.platform 1 ctx1x

400 conf = self.new_config(_utest=True) 1 ctx1x

401 

402 sys.platform = 'win32' 1 ctx1x

403 self.assertEqual(conf.default_keys(), 'IDLE Classic Windows') 1 ctx1x

404 

405 sys.platform = 'darwin' 1 ctx1x

406 self.assertEqual(conf.default_keys(), 'IDLE Classic OSX') 1 ctx1x

407 

408 sys.platform = 'some-linux' 1 ctx1x

409 self.assertEqual(conf.default_keys(), 'IDLE Modern Unix') 1 ctx1x

410 

411 # Restore platform 

412 sys.platform = current_platform 1 ctx1x

413 

414 def test_get_extensions(self): (empty)

415 userextn.read_string(''' 1 ctx1A

416 [ZzDummy] 

417 enable = True 

418 [DISABLE] 

419 enable = False 

420 ''') 

421 eq = self.assertEqual 1 ctx1A

422 iGE = idleConf.GetExtensions 1 ctx1A

423 eq(iGE(shell_only=True), []) 1 ctx1A

424 eq(iGE(), ['ZzDummy']) 1 ctx1A

425 eq(iGE(editor_only=True), ['ZzDummy']) 1 ctx1A

426 eq(iGE(active_only=False), ['ZzDummy', 'DISABLE']) 1 ctx1A

427 eq(iGE(active_only=False, editor_only=True), ['ZzDummy', 'DISABLE']) 1 ctx1A

428 userextn.remove_section('ZzDummy') 1 ctx1A

429 userextn.remove_section('DISABLE') 1 ctx1A

430 

431 

432 def test_remove_key_bind_names(self): (empty)

433 conf = self.mock_config() 1 ctx1C

434 

435 self.assertCountEqual( 1 ctx1C

436 conf.RemoveKeyBindNames(conf.GetSectionList('default', 'extensions')), 

437 ['AutoComplete', 'CodeContext', 'FormatParagraph', 'ParenMatch', 'ZzDummy']) 

438 

439 def test_get_extn_name_for_event(self): (empty)

440 userextn.read_string(''' 1 ctx1T

441 [ZzDummy] 

442 enable = True 

443 ''') 

444 eq = self.assertEqual 1 ctx1T

445 eq(idleConf.GetExtnNameForEvent('z-in'), 'ZzDummy') 1 ctx1T

446 eq(idleConf.GetExtnNameForEvent('z-out'), None) 1 ctx1T

447 userextn.remove_section('ZzDummy') 1 ctx1T

448 

449 def test_get_extension_keys(self): (empty)

450 userextn.read_string(''' 1 ctx1V

451 [ZzDummy] 

452 enable = True 

453 ''') 

454 self.assertEqual(idleConf.GetExtensionKeys('ZzDummy'), 1 ctx1V

455 {'<<z-in>>': ['<Control-Shift-KeyRelease-Insert>']}) 

456 userextn.remove_section('ZzDummy') 1 ctx1V

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): (empty)

462 userextn.read_string(''' 1 ctx1M

463 [ZzDummy] 

464 enable = True 

465 ''') 

466 eq = self.assertEqual 1 ctx1M

467 iGEB = idleConf.GetExtensionBindings 1 ctx1M

468 eq(iGEB('NotExists'), {}) 1 ctx1M

469 expect = {'<<z-in>>': ['<Control-Shift-KeyRelease-Insert>'], 1 ctx1M

470 '<<z-out>>': ['<Control-Shift-KeyRelease-Delete>']} 

471 eq(iGEB('ZzDummy'), expect) 1 ctx1M

472 userextn.remove_section('ZzDummy') 1 ctx1M

473 

474 def test_get_keybinding(self): (empty)

475 conf = self.mock_config() 1 ctx1e

476 

477 eq = self.assertEqual 1 ctx1e

478 eq(conf.GetKeyBinding('IDLE Modern Unix', '<<copy>>'), 1 ctx1e

479 ['<Control-Shift-Key-C>', '<Control-Key-Insert>']) 

480 eq(conf.GetKeyBinding('IDLE Classic Unix', '<<copy>>'), 1 ctx1e

481 ['<Alt-Key-w>', '<Meta-Key-w>']) 

482 eq(conf.GetKeyBinding('IDLE Classic Windows', '<<copy>>'), 1 ctx1e

483 ['<Control-Key-c>', '<Control-Key-C>']) 

484 eq(conf.GetKeyBinding('IDLE Classic Mac', '<<copy>>'), ['<Command-Key-c>']) 1 ctx1e

485 eq(conf.GetKeyBinding('IDLE Classic OSX', '<<copy>>'), ['<Command-Key-c>']) 1 ctx1e

486 

487 # Test keybinding not exists 

488 eq(conf.GetKeyBinding('NOT EXISTS', '<<copy>>'), []) 1 ctx1e

489 eq(conf.GetKeyBinding('IDLE Modern Unix', 'NOT EXISTS'), []) 1 ctx1e

490 

491 def test_get_current_keyset(self): (empty)

492 current_platform = sys.platform 1 ctx1p

493 conf = self.mock_config() 1 ctx1p

494 

495 # Ensure that platform isn't darwin 

496 sys.platform = 'some-linux' 1 ctx1p

497 self.assertEqual(conf.GetCurrentKeySet(), conf.GetKeySet(conf.CurrentKeys())) 1 ctx1p

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 1 ctx1p

507 

508 def test_get_keyset(self): (empty)

509 conf = self.mock_config() 1 ctx1l

510 

511 # Conflict with key set, should be disable to '' 

512 conf.defaultCfg['extensions'].add_section('Foobar') 1 ctx1l

513 conf.defaultCfg['extensions'].add_section('Foobar_cfgBindings') 1 ctx1l

514 conf.defaultCfg['extensions'].set('Foobar', 'enable', 'True') 1 ctx1l

515 conf.defaultCfg['extensions'].set('Foobar_cfgBindings', 'newfoo', '<Key-F3>') 1 ctx1l

516 self.assertEqual(conf.GetKeySet('IDLE Modern Unix')['<<newfoo>>'], '') 1 ctx1l

517 

518 def test_is_core_binding(self): (empty)

519 # XXX: Should move out the core keys to config file or other place 

520 conf = self.mock_config() 1 ctx1r

521 

522 self.assertTrue(conf.IsCoreBinding('copy')) 1 ctx1r

523 self.assertTrue(conf.IsCoreBinding('cut')) 1 ctx1r

524 self.assertTrue(conf.IsCoreBinding('del-word-right')) 1 ctx1r

525 self.assertFalse(conf.IsCoreBinding('not-exists')) 1 ctx1r

526 

527 def test_extra_help_source_list(self): (empty)

528 # Test GetExtraHelpSourceList and GetAllExtraHelpSourcesList in same 

529 # place to prevent prepare input data twice. 

530 conf = self.mock_config() 1 ctx1b

531 

532 # Test default with no extra help source 

533 self.assertEqual(conf.GetExtraHelpSourceList('default'), []) 1 ctx1b

534 self.assertEqual(conf.GetExtraHelpSourceList('user'), []) 1 ctx1b

535 with self.assertRaises(config.InvalidConfigSet): 1 ctx1b

536 self.assertEqual(conf.GetExtraHelpSourceList('bad'), []) 1 ctx1b

537 self.assertCountEqual( 1 ctx1b

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 1 ctx1b

543 conf.userCfg['main'].SetOption('HelpFiles', '3', 'Python:https://python.org') # This is bad input 1 ctx1b

544 conf.userCfg['main'].SetOption('HelpFiles', '2', 'Pillow;https://pillow.readthedocs.io/en/latest/') 1 ctx1b

545 conf.userCfg['main'].SetOption('HelpFiles', '1', 'IDLE;C:/Programs/Python36/Lib/idlelib/help.html') 1 ctx1b

546 self.assertEqual(conf.GetExtraHelpSourceList('user'), 1 ctx1b

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( 1 ctx1b

551 conf.GetAllExtraHelpSourcesList(), 

552 conf.GetExtraHelpSourceList('default') + conf.GetExtraHelpSourceList('user')) 

553 

554 def test_get_font(self): (empty)

555 from test.support import requires 1 ctx1q

556 from tkinter import Tk 1 ctx1q

557 from tkinter.font import Font 1 ctx1q

558 conf = self.mock_config() 1 ctx1q

559 

560 requires('gui') 1 ctx1q

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): (empty)

574 conf = self.mock_config() 1 ctx1d

575 

576 eq = self.assertEqual 1 ctx1d

577 eq(conf.GetCoreKeys()['<<center-insert>>'], ['<Control-l>']) 1 ctx1d

578 eq(conf.GetCoreKeys()['<<copy>>'], ['<Control-c>', '<Control-C>']) 1 ctx1d

579 eq(conf.GetCoreKeys()['<<history-next>>'], ['<Alt-n>']) 1 ctx1d

580 eq(conf.GetCoreKeys('IDLE Classic Windows')['<<center-insert>>'], 1 ctx1d

581 ['<Control-Key-l>', '<Control-Key-L>']) 

582 eq(conf.GetCoreKeys('IDLE Classic OSX')['<<copy>>'], ['<Command-Key-c>']) 1 ctx1d

583 eq(conf.GetCoreKeys('IDLE Classic Unix')['<<history-next>>'], 1 ctx1d

584 ['<Alt-Key-n>', '<Meta-Key-n>']) 

585 eq(conf.GetCoreKeys('IDLE Modern Unix')['<<history-next>>'], 1 ctx1d

586 ['<Alt-Key-n>', '<Meta-Key-n>']) 

587 

588 

589class CurrentColorKeysTest(unittest.TestCase): (empty)

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

597 default_theme = 'IDLE Classic' (empty)

598 default_keys = idleConf.default_keys() (empty)

599 

600 def test_old_builtin_theme(self): (empty)

601 # On initial installation, user main is blank. 

602 self.assertEqual(self.colorkeys('Theme'), self.default_theme) 1 ctx1G

603 # For old default, name2 must be blank. 

604 usermain.read_string(''' 1 ctx1G

605 [Theme] 

606 default = True 

607 ''') 

608 # IDLE omits 'name' for default old builtin theme. 

609 self.assertEqual(self.colorkeys('Theme'), self.default_theme) 1 ctx1G

610 # IDLE adds 'name' for non-default old builtin theme. 

611 usermain['Theme']['name'] = 'IDLE New' 1 ctx1G

612 self.assertEqual(self.colorkeys('Theme'), 'IDLE New') 1 ctx1G

613 # Erroneous non-default old builtin reverts to default. 

614 usermain['Theme']['name'] = 'non-existent' 1 ctx1G

615 self.assertEqual(self.colorkeys('Theme'), self.default_theme) 1 ctx1G

616 usermain.remove_section('Theme') 1 ctx1G

617 

618 def test_new_builtin_theme(self): (empty)

619 # IDLE writes name2 for new builtins. 

620 usermain.read_string(''' 1 ctx1N

621 [Theme] 

622 default = True 

623 name2 = IDLE Dark 

624 ''') 

625 self.assertEqual(self.colorkeys('Theme'), 'IDLE Dark') 1 ctx1N

626 # Leftover 'name', not removed, is ignored. 

627 usermain['Theme']['name'] = 'IDLE New' 1 ctx1N

628 self.assertEqual(self.colorkeys('Theme'), 'IDLE Dark') 1 ctx1N

629 # Erroneous non-default new builtin reverts to default. 

630 usermain['Theme']['name2'] = 'non-existent' 1 ctx1N

631 self.assertEqual(self.colorkeys('Theme'), self.default_theme) 1 ctx1N

632 usermain.remove_section('Theme') 1 ctx1N

633 

634 def test_user_override_theme(self): (empty)

635 # Erroneous custom name (no definition) reverts to default. 

636 usermain.read_string(''' 1 ctx1H

637 [Theme] 

638 default = False 

639 name = Custom Dark 

640 ''') 

641 self.assertEqual(self.colorkeys('Theme'), self.default_theme) 1 ctx1H