Coverage for idle_test/test_query.py: 79%

1"""Test query, coverage 93%. 

2 

3Non-gui tests for Query, SectionName, ModuleName, and HelpSource use 

4dummy versions that extract the non-gui methods and add other needed 

5attributes. GUI tests create an instance of each class and simulate 

6entries and button clicks. Subclass tests only target the new code in 

7the subclass definition. 

8 

9The appearance of the widgets is checked by the Query and 

10HelpSource htests. These are run by running query.py. 

11""" 

12from idlelib import query (empty)

13import unittest (empty)

14from test.support import requires (empty)

15from tkinter import Tk, END (empty)

16 

17import sys (empty)

18from unittest import mock (empty)

19from idlelib.idle_test.mock_tk import Var (empty)

20 

21 

22# NON-GUI TESTS 

23 

24class QueryTest(unittest.TestCase): (empty)

25 "Test Query base class." 

26 

27 class Dummy_Query: (empty)

28 # Test the following Query methods. 

29 entry_ok = query.Query.entry_ok (empty)

30 ok = query.Query.ok (empty)

31 cancel = query.Query.cancel (empty)

32 # Add attributes and initialization needed for tests. 

33 def __init__(self, dummy_entry): (empty)

34 self.entry = Var(value=dummy_entry) 5 ctx1gcdbh

35 self.entry_error = {'text': ''} 5 ctx1gcdbh

36 self.result = None 5 ctx1gcdbh

37 self.destroyed = False 5 ctx1gcdbh

38 def showerror(self, message): (empty)

39 self.entry_error['text'] = message 2 ctx1cb

40 def destroy(self): (empty)

41 self.destroyed = True 2 ctx1gh

42 

43 def test_entry_ok_blank(self): (empty)

44 dialog = self.Dummy_Query(' ') 1 ctx1c

45 self.assertEqual(dialog.entry_ok(), None) 1 ctx1c

46 self.assertEqual((dialog.result, dialog.destroyed), (None, False)) 1 ctx1c

47 self.assertIn('blank line', dialog.entry_error['text']) 1 ctx1c

48 

49 def test_entry_ok_good(self): (empty)

50 dialog = self.Dummy_Query(' good ') 1 ctx1d

51 Equal = self.assertEqual 1 ctx1d

52 Equal(dialog.entry_ok(), 'good') 1 ctx1d

53 Equal((dialog.result, dialog.destroyed), (None, False)) 1 ctx1d

54 Equal(dialog.entry_error['text'], '') 1 ctx1d

55 

56 def test_ok_blank(self): (empty)

57 dialog = self.Dummy_Query('') 1 ctx1b

58 dialog.entry.focus_set = mock.Mock() 1 ctx1b

59 self.assertEqual(dialog.ok(), None) 1 ctx1b

60 self.assertTrue(dialog.entry.focus_set.called) 1 ctx1b

61 del dialog.entry.focus_set 1 ctx1b

62 self.assertEqual((dialog.result, dialog.destroyed), (None, False)) 1 ctx1b

63 

64 def test_ok_good(self): (empty)

65 dialog = self.Dummy_Query('good') 1 ctx1h

66 self.assertEqual(dialog.ok(), None) 1 ctx1h

67 self.assertEqual((dialog.result, dialog.destroyed), ('good', True)) 1 ctx1h

68 

69 def test_cancel(self): (empty)

70 dialog = self.Dummy_Query('does not matter') 1 ctx1g

71 self.assertEqual(dialog.cancel(), None) 1 ctx1g

72 self.assertEqual((dialog.result, dialog.destroyed), (None, True)) 1 ctx1g

73 

74 

75class SectionNameTest(unittest.TestCase): (empty)

76 "Test SectionName subclass of Query." 

77 

78 class Dummy_SectionName: (empty)

79 entry_ok = query.SectionName.entry_ok # Function being tested. (empty)

80 used_names = ['used'] (empty)

81 def __init__(self, dummy_entry): (empty)

82 self.entry = Var(value=dummy_entry) 4 ctx1mwno

83 self.entry_error = {'text': ''} 4 ctx1mwno

84 def showerror(self, message): (empty)

85 self.entry_error['text'] = message 3 ctx1mno

86 

87 def test_blank_section_name(self): (empty)

88 dialog = self.Dummy_SectionName(' ') 1 ctx1m

89 self.assertEqual(dialog.entry_ok(), None) 1 ctx1m

90 self.assertIn('no name', dialog.entry_error['text']) 1 ctx1m

91 

92 def test_used_section_name(self): (empty)

93 dialog = self.Dummy_SectionName('used') 1 ctx1o

94 self.assertEqual(dialog.entry_ok(), None) 1 ctx1o

95 self.assertIn('use', dialog.entry_error['text']) 1 ctx1o

96 

97 def test_long_section_name(self): (empty)

98 dialog = self.Dummy_SectionName('good'*8) 1 ctx1n

99 self.assertEqual(dialog.entry_ok(), None) 1 ctx1n

100 self.assertIn('longer than 30', dialog.entry_error['text']) 1 ctx1n

101 

102 def test_good_section_name(self): (empty)

103 dialog = self.Dummy_SectionName(' good ') 1 ctx1w

104 self.assertEqual(dialog.entry_ok(), 'good') 1 ctx1w

105 self.assertEqual(dialog.entry_error['text'], '') 1 ctx1w

106 

107 

108class ModuleNameTest(unittest.TestCase): (empty)

109 "Test ModuleName subclass of Query." 

110 

111 class Dummy_ModuleName: (empty)

112 entry_ok = query.ModuleName.entry_ok # Function being tested. (empty)

113 text0 = '' (empty)

114 def __init__(self, dummy_entry): (empty)

115 self.entry = Var(value=dummy_entry) 4 ctx1pqri

116 self.entry_error = {'text': ''} 4 ctx1pqri

117 def showerror(self, message): (empty)

118 self.entry_error['text'] = message 3 ctx1pqr

119 

120 def test_blank_module_name(self): (empty)

121 dialog = self.Dummy_ModuleName(' ') 1 ctx1p

122 self.assertEqual(dialog.entry_ok(), None) 1 ctx1p

123 self.assertIn('no name', dialog.entry_error['text']) 1 ctx1p

124 

125 def test_bogus_module_name(self): (empty)

126 dialog = self.Dummy_ModuleName('__name_xyz123_should_not_exist__') 1 ctx1q

127 self.assertEqual(dialog.entry_ok(), None) 1 ctx1q

128 self.assertIn('not found', dialog.entry_error['text']) 1 ctx1q

129 

130 def test_c_source_name(self): (empty)

131 dialog = self.Dummy_ModuleName('itertools') 1 ctx1r

132 self.assertEqual(dialog.entry_ok(), None) 1 ctx1r

133 self.assertIn('source-based', dialog.entry_error['text']) 1 ctx1r

134 

135 def test_good_module_name(self): (empty)

136 dialog = self.Dummy_ModuleName('idlelib') 1 ctx1i

137 self.assertTrue(dialog.entry_ok().endswith('__init__.py')) 1 ctx1i

138 self.assertEqual(dialog.entry_error['text'], '') 1 ctx1i

139 dialog = self.Dummy_ModuleName('idlelib.idle') 1 ctx1i

140 self.assertTrue(dialog.entry_ok().endswith('idle.py')) 1 ctx1i

141 self.assertEqual(dialog.entry_error['text'], '') 1 ctx1i

142 

143 

144class GotoTest(unittest.TestCase): (empty)

145 "Test Goto subclass of Query." 

146 

147 class Dummy_ModuleName: (empty)

148 entry_ok = query.Goto.entry_ok # Function being tested. (empty)

149 def __init__(self, dummy_entry): (empty)

150 self.entry = Var(value=dummy_entry) 

151 self.entry_error = {'text': ''} 

152 def showerror(self, message): (empty)

153 self.entry_error['text'] = message 

154 

155 

156# 3 HelpSource test classes each test one method. 

157 

158class HelpsourceBrowsefileTest(unittest.TestCase): (empty)

159 "Test browse_file method of ModuleName subclass of Query." 

160 

161 class Dummy_HelpSource: (empty)

162 browse_file = query.HelpSource.browse_file (empty)

163 pathvar = Var() (empty)

164 

165 def test_file_replaces_path(self): (empty)

166 dialog = self.Dummy_HelpSource() 1 ctx1k

167 # Path is widget entry, either '' or something. 

168 # Func return is file dialog return, either '' or something. 

169 # Func return should override widget entry. 

170 # We need all 4 combinations to test all (most) code paths. 

171 for path, func, result in ( 1 ctx1k

172 ('', lambda a,b,c:'', ''), 

173 ('', lambda a,b,c: __file__, __file__), 

174 ('htest', lambda a,b,c:'', 'htest'), 

175 ('htest', lambda a,b,c: __file__, __file__)): 

176 with self.subTest(): 1 ctx1k

177 dialog.pathvar.set(path) 1 ctx1k

178 dialog.askfilename = func 1 ctx1k

179 dialog.browse_file() 1 ctx1k

180 self.assertEqual(dialog.pathvar.get(), result) 1 ctx1k

181 

182 

183class HelpsourcePathokTest(unittest.TestCase): (empty)

184 "Test path_ok method of HelpSource subclass of Query." 

185 

186 class Dummy_HelpSource: (empty)

187 path_ok = query.HelpSource.path_ok (empty)

188 def __init__(self, dummy_path): (empty)

189 self.path = Var(value=dummy_path) 4 ctx1stef

190 self.path_error = {'text': ''} 4 ctx1stef

191 def showerror(self, message, widget=None): (empty)

192 self.path_error['text'] = message 2 ctx1st

193 

194 orig_platform = query.platform # Set in test_path_ok_file. (empty)

195 @classmethod (empty)

196 def tearDownClass(cls): (empty)

197 query.platform = cls.orig_platform (empty)

198 

199 def test_path_ok_blank(self): (empty)

200 dialog = self.Dummy_HelpSource(' ') 1 ctx1t

201 self.assertEqual(dialog.path_ok(), None) 1 ctx1t

202 self.assertIn('no help file', dialog.path_error['text']) 1 ctx1t

203 

204 def test_path_ok_bad(self): (empty)

205 dialog = self.Dummy_HelpSource(__file__ + 'bad-bad-bad') 1 ctx1s

206 self.assertEqual(dialog.path_ok(), None) 1 ctx1s

207 self.assertIn('not exist', dialog.path_error['text']) 1 ctx1s

208 

209 def test_path_ok_web(self): (empty)

210 dialog = self.Dummy_HelpSource('') 1 ctx1f

211 Equal = self.assertEqual 1 ctx1f

212 for url in 'www.py.org', 'http://py.org': 1 ctx1f

213 with self.subTest(): 1 ctx1f

214 dialog.path.set(url) 1 ctx1f

215 self.assertEqual(dialog.path_ok(), url) 1 ctx1f

216 self.assertEqual(dialog.path_error['text'], '') 1 ctx1f

217 

218 def test_path_ok_file(self): (empty)

219 dialog = self.Dummy_HelpSource('') 1 ctx1e

220 for platform, prefix in ('darwin', 'file://'), ('other', ''): 1 ctx1e

221 with self.subTest(): 1 ctx1e

222 query.platform = platform 1 ctx1e

223 dialog.path.set(__file__) 1 ctx1e

224 self.assertEqual(dialog.path_ok(), prefix + __file__) 1 ctx1e

225 self.assertEqual(dialog.path_error['text'], '') 1 ctx1e

226 

227 

228class HelpsourceEntryokTest(unittest.TestCase): (empty)

229 "Test entry_ok method of HelpSource subclass of Query." 

230 

231 class Dummy_HelpSource: (empty)

232 entry_ok = query.HelpSource.entry_ok (empty)

233 entry_error = {} (empty)

234 path_error = {} (empty)

235 def item_ok(self): (empty)

236 return self.name 1 ctx1l

237 def path_ok(self): (empty)

238 return self.path 1 ctx1l

239 

240 def test_entry_ok_helpsource(self): (empty)

241 dialog = self.Dummy_HelpSource() 1 ctx1l

242 for name, path, result in ((None, None, None), 1 ctx1l

243 (None, 'doc.txt', None), 

244 ('doc', None, None), 

245 ('doc', 'doc.txt', ('doc', 'doc.txt'))): 

246 with self.subTest(): 1 ctx1l

247 dialog.name, dialog.path = name, path 1 ctx1l

248 self.assertEqual(dialog.entry_ok(), result) 1 ctx1l

249 

250 

251# 2 CustomRun test classes each test one method. 

252 

253class CustomRunCLIargsokTest(unittest.TestCase): (empty)

254 "Test cli_ok method of the CustomRun subclass of Query." 

255 

256 class Dummy_CustomRun: (empty)

257 cli_args_ok = query.CustomRun.cli_args_ok (empty)

258 def __init__(self, dummy_entry): (empty)

259 self.entry = Var(value=dummy_entry) 3 ctx1xuv

260 self.entry_error = {'text': ''} 3 ctx1xuv

261 def showerror(self, message): (empty)

262 self.entry_error['text'] = message 1 ctx1v

263 

264 def test_blank_args(self): (empty)

265 dialog = self.Dummy_CustomRun(' ') 1 ctx1x

266 self.assertEqual(dialog.cli_args_ok(), []) 1 ctx1x

267 

268 def test_invalid_args(self): (empty)

269 dialog = self.Dummy_CustomRun("'no-closing-quote") 1 ctx1v

270 self.assertEqual(dialog.cli_args_ok(), None) 1 ctx1v

271 self.assertIn('No closing', dialog.entry_error['text']) 1 ctx1v

272 

273 def test_good_args(self): (empty)

274 args = ['-n', '10', '--verbose', '-p', '/path', '--name'] 1 ctx1u

275 dialog = self.Dummy_CustomRun(' '.join(args) + ' "my name"') 1 ctx1u

276 self.assertEqual(dialog.cli_args_ok(), args + ["my name"]) 1 ctx1u

277 self.assertEqual(dialog.entry_error['text'], '') 1 ctx1u

278 

279 

280class CustomRunEntryokTest(unittest.TestCase): (empty)

281 "Test entry_ok method of the CustomRun subclass of Query." 

282 

283 class Dummy_CustomRun: (empty)

284 entry_ok = query.CustomRun.entry_ok (empty)

285 entry_error = {} (empty)

286 restartvar = Var() (empty)

287 def cli_args_ok(self): (empty)

288 return self.cli_args 1 ctx1j

289 

290 def test_entry_ok_customrun(self): (empty)

291 dialog = self.Dummy_CustomRun() 1 ctx1j

292 for restart in {True, False}: 1 ctx1j

293 dialog.restartvar.set(restart) 1 ctx1j

294 for cli_args, result in ((None, None), 1 ctx1j

295 (['my arg'], (['my arg'], restart))): 

296 with self.subTest(restart=restart, cli_args=cli_args): 1 ctx1j

297 dialog.cli_args = cli_args 1 ctx1j

298 self.assertEqual(dialog.entry_ok(), result) 1 ctx1j

299 

300 

301# GUI TESTS 

302 

303class QueryGuiTest(unittest.TestCase): (empty)

304 

305 @classmethod (empty)

306 def setUpClass(cls): (empty)

307 requires('gui') (empty)

308 cls.root = root = Tk() 

309 cls.root.withdraw() 

310 cls.dialog = query.Query(root, 'TEST', 'test', _utest=True) 

311 cls.dialog.destroy = mock.Mock() 

312 

313 @classmethod (empty)

314 def tearDownClass(cls): (empty)

315 del cls.dialog.destroy 

316 del cls.dialog 

317 cls.root.destroy() 

318 del cls.root 

319 

320 def setUp(self): (empty)

321 self.dialog.entry.delete(0, 'end') 

322 self.dialog.result = None 

323 self.dialog.destroy.reset_mock() 

324 

325 def test_click_ok(self): (empty)

326 dialog = self.dialog 

327 dialog.entry.insert(0, 'abc') 

328 dialog.button_ok.invoke() 

329 self.assertEqual(dialog.result, 'abc') 

330 self.assertTrue(dialog.destroy.called) 

331 

332 def test_click_blank(self): (empty)

333 dialog = self.dialog 

334 dialog.button_ok.invoke() 

335 self.assertEqual(dialog.result, None) 

336 self.assertFalse(dialog.destroy.called) 

337 

338 def test_click_cancel(self): (empty)

339 dialog = self.dialog 

340 dialog.entry.insert(0, 'abc') 

341 dialog.button_cancel.invoke() 

342 self.assertEqual(dialog.result, None) 

343 self.assertTrue(dialog.destroy.called) 

344 

345 

346class SectionnameGuiTest(unittest.TestCase): (empty)

347 

348 @classmethod (empty)

349 def setUpClass(cls): (empty)

350 requires('gui') (empty)

351 

352 def test_click_section_name(self): (empty)

353 root = Tk() 

354 root.withdraw() 

355 dialog = query.SectionName(root, 'T', 't', {'abc'}, _utest=True) 

356 Equal = self.assertEqual 

357 self.assertEqual(dialog.used_names, {'abc'}) 

358 dialog.entry.insert(0, 'okay') 

359 dialog.button_ok.invoke() 

360 self.assertEqual(dialog.result, 'okay') 

361 root.destroy() 

362 

363 

364class ModulenameGuiTest(unittest.TestCase): (empty)

365 

366 @classmethod (empty)

367 def setUpClass(cls): (empty)

368 requires('gui') (empty)

369 

370 def test_click_module_name(self): (empty)

371 root = Tk() 

372 root.withdraw() 

373 dialog = query.ModuleName(root, 'T', 't', 'idlelib', _utest=True) 

374 self.assertEqual(dialog.text0, 'idlelib') 

375 self.assertEqual(dialog.entry.get(), 'idlelib') 

376 dialog.button_ok.invoke() 

377 self.assertTrue(dialog.result.endswith('__init__.py')) 

378 root.destroy() 

379 

380 

381class GotoGuiTest(unittest.TestCase): (empty)

382 

383 @classmethod (empty)

384 def setUpClass(cls): (empty)

385 requires('gui') (empty)

386 

387 def test_click_module_name(self): (empty)

388 root = Tk() 

389 root.withdraw() 

390 dialog = query.Goto(root, 'T', 't', _utest=True) 

391 dialog.entry.insert(0, '22') 

392 dialog.button_ok.invoke() 

393 self.assertEqual(dialog.result, 22) 

394 root.destroy() 

395 

396 

397class HelpsourceGuiTest(unittest.TestCase): (empty)

398 

399 @classmethod (empty)

400 def setUpClass(cls): (empty)

401 requires('gui') (empty)

402 

403 def test_click_help_source(self): (empty)

404 root = Tk() 

405 root.withdraw() 

406 dialog = query.HelpSource(root, 'T', menuitem='__test__', 

407 filepath=__file__, _utest=True) 

408 Equal = self.assertEqual 

409 Equal(dialog.entry.get(), '__test__') 

410 Equal(dialog.path.get(), __file__) 

411 dialog.button_ok.invoke() 

412 prefix = "file://" if sys.platform == 'darwin' else '' 

413 Equal(dialog.result, ('__test__', prefix + __file__)) 

414 root.destroy() 

415 

416 

417class CustomRunGuiTest(unittest.TestCase): (empty)

418 

419 @classmethod (empty)

420 def setUpClass(cls): (empty)

421 requires('gui') (empty)

422 

423 def test_click_args(self): (empty)

424 root = Tk() 

425 root.withdraw() 

426 dialog = query.CustomRun(root, 'Title', 

427 cli_args=['a', 'b=1'], _utest=True) 

428 self.assertEqual(dialog.entry.get(), 'a b=1') 

429 dialog.entry.insert(END, ' c') 

430 dialog.button_ok.invoke() 

431 self.assertEqual(dialog.result, (['a', 'b=1', 'c'], True)) 

432 root.destroy() 

433 

434 

435if __name__ == '__main__': 435 ↛ 436line 435 didn't jump to line 436, because the condition on line 435 was never true(empty)

436 unittest.main(verbosity=2, exit=False)