test_query.py

"""Test query, coverage 93%.

Non-gui tests for Query, SectionName, ModuleName, and HelpSource use
dummy versions that extract the non-gui methods and add other needed
attributes. GUI tests create an instance of each class and simulate
entries and button clicks. Subclass tests only target the new code in
the subclass definition.

The appearance of the widgets is checked by the Query and
HelpSource htests. These are run by running query.py.
"""
fromidlelibimportquery
importunittest
fromtest.supportimportrequires
fromtest.support.testcaseimportExtraAssertions
fromtkinterimportTk, END

importsys
fromunittestimportmock
fromidlelib.idle_test.mock_tkimportVar


# NON-GUI TESTS

classQueryTest(unittest.TestCase):
"Test Query base class."

classDummy_Query:
# Test the following Query methods.
entry_ok=query.Query.entry_ok
ok=query.Query.ok
cancel=query.Query.cancel
# Add attributes and initialization needed for tests.
def__init__(self, dummy_entry):
self.entry=Var(value=dummy_entry)
self.entry_error= {'text': ''}
self.result=None
self.destroyed=False
defshowerror(self, message):
self.entry_error['text'] =message
defdestroy(self):
self.destroyed=True

deftest_entry_ok_blank(self):
dialog=self.Dummy_Query(' ')
self.assertEqual(dialog.entry_ok(), None)
self.assertEqual((dialog.result, dialog.destroyed), (None, False))
self.assertIn('blank line', dialog.entry_error['text'])

deftest_entry_ok_good(self):
dialog=self.Dummy_Query(' good ')
Equal=self.assertEqual
Equal(dialog.entry_ok(), 'good')
Equal((dialog.result, dialog.destroyed), (None, False))
Equal(dialog.entry_error['text'], '')

deftest_ok_blank(self):
dialog=self.Dummy_Query('')
dialog.entry.focus_set=mock.Mock()
self.assertEqual(dialog.ok(), None)
self.assertTrue(dialog.entry.focus_set.called)
deldialog.entry.focus_set
self.assertEqual((dialog.result, dialog.destroyed), (None, False))

deftest_ok_good(self):
dialog=self.Dummy_Query('good')
self.assertEqual(dialog.ok(), None)
self.assertEqual((dialog.result, dialog.destroyed), ('good', True))

deftest_cancel(self):
dialog=self.Dummy_Query('does not matter')
self.assertEqual(dialog.cancel(), None)
self.assertEqual((dialog.result, dialog.destroyed), (None, True))


classSectionNameTest(unittest.TestCase):
"Test SectionName subclass of Query."

classDummy_SectionName:
entry_ok=query.SectionName.entry_ok# Function being tested.
used_names= ['used']
def__init__(self, dummy_entry):
self.entry=Var(value=dummy_entry)
self.entry_error= {'text': ''}
defshowerror(self, message):
self.entry_error['text'] =message

deftest_blank_section_name(self):
dialog=self.Dummy_SectionName(' ')
self.assertEqual(dialog.entry_ok(), None)
self.assertIn('no name', dialog.entry_error['text'])

deftest_used_section_name(self):
dialog=self.Dummy_SectionName('used')
self.assertEqual(dialog.entry_ok(), None)
self.assertIn('use', dialog.entry_error['text'])

deftest_long_section_name(self):
dialog=self.Dummy_SectionName('good'*8)
self.assertEqual(dialog.entry_ok(), None)
self.assertIn('longer than 30', dialog.entry_error['text'])

deftest_good_section_name(self):
dialog=self.Dummy_SectionName(' good ')
self.assertEqual(dialog.entry_ok(), 'good')
self.assertEqual(dialog.entry_error['text'], '')


classModuleNameTest(unittest.TestCase, ExtraAssertions):
"Test ModuleName subclass of Query."

classDummy_ModuleName:
entry_ok=query.ModuleName.entry_ok# Function being tested.
text0=''
def__init__(self, dummy_entry):
self.entry=Var(value=dummy_entry)
self.entry_error= {'text': ''}
defshowerror(self, message):
self.entry_error['text'] =message

deftest_blank_module_name(self):
dialog=self.Dummy_ModuleName(' ')
self.assertEqual(dialog.entry_ok(), None)
self.assertIn('no name', dialog.entry_error['text'])

deftest_bogus_module_name(self):
dialog=self.Dummy_ModuleName('__name_xyz123_should_not_exist__')
self.assertEqual(dialog.entry_ok(), None)
self.assertIn('not found', dialog.entry_error['text'])

deftest_c_source_name(self):
dialog=self.Dummy_ModuleName('itertools')
self.assertEqual(dialog.entry_ok(), None)
self.assertIn('source-based', dialog.entry_error['text'])

deftest_good_module_name(self):
dialog=self.Dummy_ModuleName('idlelib')
self.assertEndsWith(dialog.entry_ok(), '__init__.py')
self.assertEqual(dialog.entry_error['text'], '')
dialog=self.Dummy_ModuleName('idlelib.idle')
self.assertEndsWith(dialog.entry_ok(), 'idle.py')
self.assertEqual(dialog.entry_error['text'], '')


classGotoTest(unittest.TestCase):
"Test Goto subclass of Query."

classDummy_ModuleName:
entry_ok=query.Goto.entry_ok# Function being tested.
def__init__(self, dummy_entry):
self.entry=Var(value=dummy_entry)
self.entry_error= {'text': ''}
defshowerror(self, message):
self.entry_error['text'] =message

deftest_bogus_goto(self):
dialog=self.Dummy_ModuleName('a')
self.assertEqual(dialog.entry_ok(), None)
self.assertIn('not a base 10 integer', dialog.entry_error['text'])

deftest_bad_goto(self):
dialog=self.Dummy_ModuleName('0')
self.assertEqual(dialog.entry_ok(), None)
self.assertIn('not a positive integer', dialog.entry_error['text'])

deftest_good_goto(self):
dialog=self.Dummy_ModuleName('1')
self.assertEqual(dialog.entry_ok(), 1)
self.assertEqual(dialog.entry_error['text'], '')


# 3 HelpSource test classes each test one method.

classHelpsourceBrowsefileTest(unittest.TestCase):
"Test browse_file method of ModuleName subclass of Query."

classDummy_HelpSource:
browse_file=query.HelpSource.browse_file
pathvar=Var()

deftest_file_replaces_path(self):
dialog=self.Dummy_HelpSource()
# Path is widget entry, either '' or something.
# Func return is file dialog return, either '' or something.
# Func return should override widget entry.
# We need all 4 combinations to test all (most) code paths.
forpath, func, resultin (
 ('', lambdaa,b,c:'', ''),
 ('', lambdaa,b,c: __file__, __file__),
 ('htest', lambdaa,b,c:'', 'htest'),
 ('htest', lambdaa,b,c: __file__, __file__)):
withself.subTest():
dialog.pathvar.set(path)
dialog.askfilename=func
dialog.browse_file()
self.assertEqual(dialog.pathvar.get(), result)


classHelpsourcePathokTest(unittest.TestCase):
"Test path_ok method of HelpSource subclass of Query."

classDummy_HelpSource:
path_ok=query.HelpSource.path_ok
def__init__(self, dummy_path):
self.path=Var(value=dummy_path)
self.path_error= {'text': ''}
defshowerror(self, message, widget=None):
self.path_error['text'] =message

orig_platform=query.platform# Set in test_path_ok_file.
@classmethod
deftearDownClass(cls):
query.platform=cls.orig_platform

deftest_path_ok_blank(self):
dialog=self.Dummy_HelpSource(' ')
self.assertEqual(dialog.path_ok(), None)
self.assertIn('no help file', dialog.path_error['text'])

deftest_path_ok_bad(self):
dialog=self.Dummy_HelpSource(__file__+'bad-bad-bad')
self.assertEqual(dialog.path_ok(), None)
self.assertIn('not exist', dialog.path_error['text'])

deftest_path_ok_web(self):
dialog=self.Dummy_HelpSource('')
Equal=self.assertEqual
forurlin'www.py.org', 'http://py.org':
withself.subTest():
dialog.path.set(url)
self.assertEqual(dialog.path_ok(), url)
self.assertEqual(dialog.path_error['text'], '')

deftest_path_ok_file(self):
dialog=self.Dummy_HelpSource('')
forplatform, prefixin ('darwin', 'file://'), ('other', ''):
withself.subTest():
query.platform=platform
dialog.path.set(__file__)
self.assertEqual(dialog.path_ok(), prefix+__file__)
self.assertEqual(dialog.path_error['text'], '')


classHelpsourceEntryokTest(unittest.TestCase):
"Test entry_ok method of HelpSource subclass of Query."

classDummy_HelpSource:
entry_ok=query.HelpSource.entry_ok
entry_error= {}
path_error= {}
defitem_ok(self):
returnself.name
defpath_ok(self):
returnself.path

deftest_entry_ok_helpsource(self):
dialog=self.Dummy_HelpSource()
forname, path, resultin ((None, None, None),
 (None, 'doc.txt', None),
 ('doc', None, None),
 ('doc', 'doc.txt', ('doc', 'doc.txt'))):
withself.subTest():
dialog.name, dialog.path=name, path
self.assertEqual(dialog.entry_ok(), result)


# 2 CustomRun test classes each test one method.

classCustomRunCLIargsokTest(unittest.TestCase):
"Test cli_ok method of the CustomRun subclass of Query."

classDummy_CustomRun:
cli_args_ok=query.CustomRun.cli_args_ok
def__init__(self, dummy_entry):
self.entry=Var(value=dummy_entry)
self.entry_error= {'text': ''}
defshowerror(self, message):
self.entry_error['text'] =message

deftest_blank_args(self):
dialog=self.Dummy_CustomRun(' ')
self.assertEqual(dialog.cli_args_ok(), [])

deftest_invalid_args(self):
dialog=self.Dummy_CustomRun("'no-closing-quote")
self.assertEqual(dialog.cli_args_ok(), None)
self.assertIn('No closing', dialog.entry_error['text'])

deftest_good_args(self):
args= ['-n', '10', '--verbose', '-p', '/path', '--name']
dialog=self.Dummy_CustomRun(' '.join(args) +' "my name"')
self.assertEqual(dialog.cli_args_ok(), args+ ["my name"])
self.assertEqual(dialog.entry_error['text'], '')


classCustomRunEntryokTest(unittest.TestCase):
"Test entry_ok method of the CustomRun subclass of Query."

classDummy_CustomRun:
entry_ok=query.CustomRun.entry_ok
entry_error= {}
restartvar=Var()
defcli_args_ok(self):
returnself.cli_args

deftest_entry_ok_customrun(self):
dialog=self.Dummy_CustomRun()
forrestartin {True, False}:
dialog.restartvar.set(restart)
forcli_args, resultin ((None, None),
 (['my arg'], (['my arg'], restart))):
withself.subTest(restart=restart, cli_args=cli_args):
dialog.cli_args=cli_args
self.assertEqual(dialog.entry_ok(), result)


# GUI TESTS

classQueryGuiTest(unittest.TestCase):

@classmethod
defsetUpClass(cls):
requires('gui')
cls.root=root=Tk()
cls.root.withdraw()
cls.dialog=query.Query(root, 'TEST', 'test', _utest=True)
cls.dialog.destroy=mock.Mock()

@classmethod
deftearDownClass(cls):
delcls.dialog.destroy
delcls.dialog
cls.root.destroy()
delcls.root

defsetUp(self):
self.dialog.entry.delete(0, 'end')
self.dialog.result=None
self.dialog.destroy.reset_mock()

deftest_click_ok(self):
dialog=self.dialog
dialog.entry.insert(0, 'abc')
dialog.button_ok.invoke()
self.assertEqual(dialog.result, 'abc')
self.assertTrue(dialog.destroy.called)

deftest_click_blank(self):
dialog=self.dialog
dialog.button_ok.invoke()
self.assertEqual(dialog.result, None)
self.assertFalse(dialog.destroy.called)

deftest_click_cancel(self):
dialog=self.dialog
dialog.entry.insert(0, 'abc')
dialog.button_cancel.invoke()
self.assertEqual(dialog.result, None)
self.assertTrue(dialog.destroy.called)


classSectionnameGuiTest(unittest.TestCase):

@classmethod
defsetUpClass(cls):
requires('gui')

deftest_click_section_name(self):
root=Tk()
root.withdraw()
dialog=query.SectionName(root, 'T', 't', {'abc'}, _utest=True)
Equal=self.assertEqual
self.assertEqual(dialog.used_names, {'abc'})
dialog.entry.insert(0, 'okay')
dialog.button_ok.invoke()
self.assertEqual(dialog.result, 'okay')
root.destroy()


classModulenameGuiTest(unittest.TestCase, ExtraAssertions):

@classmethod
defsetUpClass(cls):
requires('gui')

deftest_click_module_name(self):
root=Tk()
root.withdraw()
dialog=query.ModuleName(root, 'T', 't', 'idlelib', _utest=True)
self.assertEqual(dialog.text0, 'idlelib')
self.assertEqual(dialog.entry.get(), 'idlelib')
dialog.button_ok.invoke()
self.assertEndsWith(dialog.result, '__init__.py')
root.destroy()


classGotoGuiTest(unittest.TestCase):

@classmethod
defsetUpClass(cls):
requires('gui')

deftest_click_module_name(self):
root=Tk()
root.withdraw()
dialog=query.Goto(root, 'T', 't', _utest=True)
dialog.entry.insert(0, '22')
dialog.button_ok.invoke()
self.assertEqual(dialog.result, 22)
root.destroy()


classHelpsourceGuiTest(unittest.TestCase):

@classmethod
defsetUpClass(cls):
requires('gui')

deftest_click_help_source(self):
root=Tk()
root.withdraw()
dialog=query.HelpSource(root, 'T', menuitem='__test__',
filepath=__file__, _utest=True)
Equal=self.assertEqual
Equal(dialog.entry.get(), '__test__')
Equal(dialog.path.get(), __file__)
dialog.button_ok.invoke()
prefix="file://"ifsys.platform=='darwin'else''
Equal(dialog.result, ('__test__', prefix+__file__))
root.destroy()


classCustomRunGuiTest(unittest.TestCase):

@classmethod
defsetUpClass(cls):
requires('gui')

deftest_click_args(self):
root=Tk()
root.withdraw()
dialog=query.CustomRun(root, 'Title',
cli_args=['a', 'b=1'], _utest=True)
self.assertEqual(dialog.entry.get(), 'a b=1')
dialog.entry.insert(END, ' c')
dialog.button_ok.invoke()
self.assertEqual(dialog.result, (['a', 'b=1', 'c'], True))
root.destroy()


if__name__=='__main__':
unittest.main(verbosity=2, exit=False)