| "Test zzdummy, coverage 100%." |
| |
| from idlelib import zzdummy |
| import unittest |
| from test.support import requires |
| from tkinter import Tk, Text |
| from unittest import mock |
| from idlelib import config |
| from idlelib import editor |
| from idlelib import format |
| |
| |
| usercfg = zzdummy.idleConf.userCfg |
| testcfg = { |
| 'main': config.IdleUserConfParser(''), |
| 'highlight': config.IdleUserConfParser(''), |
| 'keys': config.IdleUserConfParser(''), |
| 'extensions': config.IdleUserConfParser(''), |
| } |
| code_sample = """\ |
| |
| class C1: |
| # Class comment. |
| def __init__(self, a, b): |
| self.a = a |
| self.b = b |
| """ |
| |
| |
| class DummyEditwin: |
| get_selection_indices = editor.EditorWindow.get_selection_indices |
| def __init__(self, root, text): |
| self.root = root |
| self.top = root |
| self.text = text |
| self.fregion = format.FormatRegion(self) |
| self.text.undo_block_start = mock.Mock() |
| self.text.undo_block_stop = mock.Mock() |
| |
| |
| class ZZDummyMixin: |
| """Shared tests for ZzDummy with default and user configs.""" |
| |
| def checklines(self, text, value): |
| # Verify that there are lines being checked. |
| end_line = int(float(text.index('end'))) |
| |
| # Check each line for the starting text. |
| actual = [] |
| for line in range(1, end_line): |
| txt = text.get(f'{line}.0', f'{line}.end') |
| actual.append(txt.startswith(value)) |
| return actual |
| |
| def test_init(self): |
| zz = self.zz |
| self.assertEqual(zz.editwin, self.editor) |
| self.assertEqual(zz.text, self.editor.text) |
| |
| def test_reload(self): |
| self.assertEqual(self.zz.ztext, '# ignore #') |
| zzdummy.idleConf.userCfg['extensions'].SetOption( |
| 'ZzDummy', 'z-text', 'spam') |
| zzdummy.ZzDummy.reload() |
| self.assertEqual(self.zz.ztext, 'spam') |
| |
| def test_z_in_event(self): |
| eq = self.assertEqual |
| zz = self.zz |
| text = zz.text |
| eq(self.zz.ztext, '# ignore #') |
| |
| # No lines have the leading text. |
| expected = [False, False, False, False, False, False, False] |
| actual = self.checklines(text, zz.ztext) |
| eq(expected, actual) |
| |
| text.tag_add('sel', '2.0', '4.end') |
| eq(zz.z_in_event(), 'break') |
| expected = [False, True, True, True, False, False, False] |
| actual = self.checklines(text, zz.ztext) |
| eq(expected, actual) |
| |
| text.undo_block_start.assert_called_once() |
| text.undo_block_stop.assert_called_once() |
| |
| def test_z_out_event(self): |
| eq = self.assertEqual |
| zz = self.zz |
| text = zz.text |
| eq(self.zz.ztext, '# ignore #') |
| |
| # Prepend text. |
| text.tag_add('sel', '2.0', '5.end') |
| zz.z_in_event() |
| text.undo_block_start.reset_mock() |
| text.undo_block_stop.reset_mock() |
| |
| # Select a few lines to remove text. |
| text.tag_remove('sel', '1.0', 'end') |
| text.tag_add('sel', '3.0', '4.end') |
| eq(zz.z_out_event(), 'break') |
| expected = [False, True, False, False, True, False, False] |
| actual = self.checklines(text, zz.ztext) |
| eq(expected, actual) |
| |
| text.undo_block_start.assert_called_once() |
| text.undo_block_stop.assert_called_once() |
| |
| def test_roundtrip(self): |
| # Insert and remove to all code should give back original text. |
| zz = self.zz |
| text = zz.text |
| |
| text.tag_add('sel', '1.0', 'end-1c') |
| zz.z_in_event() |
| zz.z_out_event() |
| |
| self.assertEqual(text.get('1.0', 'end-1c'), code_sample) |
| |
| |
| class ZZDummyTest(ZZDummyMixin, unittest.TestCase): |
| |
| @classmethod |
| def setUpClass(cls): |
| requires('gui') |
| root = cls.root = Tk() |
| root.withdraw() |
| text = cls.text = Text(cls.root) |
| cls.editor = DummyEditwin(root, text) |
| zzdummy.idleConf.userCfg = testcfg |
| |
| @classmethod |
| def tearDownClass(cls): |
| zzdummy.idleConf.userCfg = usercfg |
| del cls.editor, cls.text |
| cls.root.update_idletasks() |
| for id in cls.root.tk.call('after', 'info'): |
| cls.root.after_cancel(id) # Need for EditorWindow. |
| cls.root.destroy() |
| del cls.root |
| |
| def setUp(self): |
| text = self.text |
| text.insert('1.0', code_sample) |
| text.undo_block_start.reset_mock() |
| text.undo_block_stop.reset_mock() |
| zz = self.zz = zzdummy.ZzDummy(self.editor) |
| zzdummy.ZzDummy.ztext = '# ignore #' |
| |
| def tearDown(self): |
| self.text.delete('1.0', 'end') |
| del self.zz |
| |
| def test_exists(self): |
| conf = zzdummy.idleConf |
| self.assertEqual( |
| conf.GetSectionList('user', 'extensions'), []) |
| self.assertEqual( |
| conf.GetSectionList('default', 'extensions'), |
| ['AutoComplete', 'CodeContext', 'FormatParagraph', |
| 'ParenMatch', 'ZzDummy', 'ZzDummy_cfgBindings', |
| 'ZzDummy_bindings']) |
| self.assertIn("ZzDummy", conf.GetExtensions(False)) |
| self.assertNotIn("ZzDummy", conf.GetExtensions()) |
| self.assertEqual( |
| conf.GetExtensionKeys("ZzDummy"), {}) |
| self.assertEqual( |
| conf.GetExtensionBindings("ZzDummy"), |
| {'<<z-out>>': ['<Control-Shift-KeyRelease-Delete>']}) |
| |
| def test_exists_user(self): |
| conf = zzdummy.idleConf |
| conf.userCfg["extensions"].read_dict({ |
| "ZzDummy": {'enable': 'True'} |
| }) |
| self.assertEqual( |
| conf.GetSectionList('user', 'extensions'), |
| ["ZzDummy"]) |
| self.assertIn("ZzDummy", conf.GetExtensions()) |
| self.assertEqual( |
| conf.GetExtensionKeys("ZzDummy"), |
| {'<<z-in>>': ['<Control-Shift-KeyRelease-Insert>']}) |
| self.assertEqual( |
| conf.GetExtensionBindings("ZzDummy"), |
| {'<<z-in>>': ['<Control-Shift-KeyRelease-Insert>'], |
| '<<z-out>>': ['<Control-Shift-KeyRelease-Delete>']}) |
| # Restore |
| conf.userCfg["extensions"].remove_section("ZzDummy") |
| |
| |
| if __name__ == '__main__': |
| unittest.main(verbosity=2) |
