tests/test_gio.py

   1 # -*- Mode: Python; py-indent-offset: 4 -*-
   2 # vim: tabstop=4 shiftwidth=4 expandtab
   3
   4 import unittest
   5
   6 import gi.overrides
   7 from gi.repository import GLib, Gio
   8
   9
  10 class TestGio(unittest.TestCase):
  11     def test_file_enumerator(self):
  12         self.assertEqual(Gio.FileEnumerator, gi.overrides.Gio.FileEnumerator)
  13         f = Gio.file_new_for_path("./")
  14
  15         iter_info = []
  16         for info in f.enumerate_children("standard::*", 0, None):
  17             iter_info.append(info.get_name())
  18
  19         next_info = []
  20         enumerator = f.enumerate_children("standard::*", 0, None)
  21         while True:
  22             info = enumerator.next_file(None)
  23             if info is None:
  24                 break
  25             next_info.append(info.get_name())
  26
  27         self.assertEqual(iter_info, next_info)
  28
  29     def test_menu_item(self):
  30         menu = Gio.Menu()
  31         item = Gio.MenuItem()
  32         item.set_attribute([("label", "s", "Test"),
  33                             ("action", "s", "app.test")])
  34         menu.append_item(item)
  35         value = menu.get_item_attribute_value(0, "label", GLib.VariantType.new("s"))
  36         self.assertEqual("Test", value.unpack())
  37         value = menu.get_item_attribute_value(0, "action", GLib.VariantType.new("s"))
  38         self.assertEqual("app.test", value.unpack())
  39
  40
  41 class TestGSettings(unittest.TestCase):
  42     def setUp(self):
  43         self.settings = Gio.Settings('org.gnome.test')
  44         # we change the values in the tests, so set them to predictable start
  45         # value
  46         self.settings.reset('test-string')
  47         self.settings.reset('test-array')
  48         self.settings.reset('test-boolean')
  49         self.settings.reset('test-enum')
  50
  51     def test_native(self):
  52         self.assertTrue('test-array' in self.settings.list_keys())
  53
  54         # get various types
  55         v = self.settings.get_value('test-boolean')
  56         self.assertEqual(v.get_boolean(), True)
  57         self.assertEqual(self.settings.get_boolean('test-boolean'), True)
  58
  59         v = self.settings.get_value('test-string')
  60         self.assertEqual(v.get_string(), 'Hello')
  61         self.assertEqual(self.settings.get_string('test-string'), 'Hello')
  62
  63         v = self.settings.get_value('test-array')
  64         self.assertEqual(v.unpack(), [1, 2])
  65
  66         v = self.settings.get_value('test-tuple')
  67         self.assertEqual(v.unpack(), (1, 2))
  68
  69         # set a value
  70         self.settings.set_string('test-string', 'World')
  71         self.assertEqual(self.settings.get_string('test-string'), 'World')
  72
  73         self.settings.set_value('test-string', GLib.Variant('s', 'Goodbye'))
  74         self.assertEqual(self.settings.get_string('test-string'), 'Goodbye')
  75
  76     def test_constructor(self):
  77         # default constructor uses path from schema
  78         self.assertEqual(self.settings.get_property('path'), '/tests/')
  79
  80         # optional constructor arguments
  81         with_path = Gio.Settings('org.gnome.nopathtest', path='/mypath/')
  82         self.assertEqual(with_path.get_property('path'), '/mypath/')
  83         self.assertEqual(with_path['np-int'], 42)
  84
  85     def test_dictionary_api(self):
  86         self.assertEqual(len(self.settings), 5)
  87         self.assertTrue('test-array' in self.settings)
  88         self.assertTrue('test-array' in self.settings.keys())
  89         self.assertFalse('nonexisting' in self.settings)
  90         self.assertFalse(4 in self.settings)
  91         self.assertEqual(bool(self.settings), True)
  92
  93     def test_get(self):
  94         self.assertEqual(self.settings['test-boolean'], True)
  95         self.assertEqual(self.settings['test-string'], 'Hello')
  96         self.assertEqual(self.settings['test-enum'], 'banana')
  97         self.assertEqual(self.settings['test-array'], [1, 2])
  98         self.assertEqual(self.settings['test-tuple'], (1, 2))
  99
 100         self.assertRaises(KeyError, self.settings.__getitem__, 'unknown')
 101         self.assertRaises(KeyError, self.settings.__getitem__, 2)
 102
 103     def test_set(self):
 104         self.settings['test-boolean'] = False
 105         self.assertEqual(self.settings['test-boolean'], False)
 106         self.settings['test-string'] = 'Goodbye'
 107         self.assertEqual(self.settings['test-string'], 'Goodbye')
 108         self.settings['test-array'] = [3, 4, 5]
 109         self.assertEqual(self.settings['test-array'], [3, 4, 5])
 110         self.settings['test-enum'] = 'pear'
 111         self.assertEqual(self.settings['test-enum'], 'pear')
 112
 113         self.assertRaises(TypeError, self.settings.__setitem__, 'test-string', 1)
 114         self.assertRaises(ValueError, self.settings.__setitem__, 'test-enum', 'plum')
 115         self.assertRaises(KeyError, self.settings.__setitem__, 'unknown', 'moo')
 116
 117     def test_empty(self):
 118         empty = Gio.Settings('org.gnome.empty', path='/tests/')
 119         self.assertEqual(len(empty), 0)
 120         self.assertEqual(bool(empty), True)
 121         self.assertEqual(empty.keys(), [])
 122
 123     def test_change_event(self):
 124         changed_log = []
 125         change_event_log = []
 126
 127         def on_changed(settings, key):
 128             changed_log.append((settings, key))
 129
 130         def on_change_event(settings, keys, n_keys):
 131             change_event_log.append((settings, keys, n_keys))
 132
 133         self.settings.connect('changed', on_changed)
 134         self.settings.connect('change-event', on_change_event)
 135         self.settings['test-string'] = 'Moo'
 136         self.assertEqual(changed_log, [(self.settings, 'test-string')])
 137         self.assertEqual(change_event_log, [(self.settings,
 138                                              [GLib.quark_from_static_string('test-string')],
 139                                              1)])
 140
 141
 142 class TestGFile(unittest.TestCase):
 143     def setUp(self):
 144         self.file, self.io_stream = Gio.File.new_tmp('TestGFile.XXXXXX')
 145
 146     def tearDown(self):
 147         try:
 148             self.file.delete(None)
 149             # test_delete and test_delete_async already remove it
 150         except GLib.GError:
 151             pass
 152
 153     def test_replace_contents(self):
 154         content = b'hello\0world\x7F!'
 155         succ, etag = self.file.replace_contents(content, None, False,
 156                                                 Gio.FileCreateFlags.NONE, None)
 157         new_succ, new_content, new_etag = self.file.load_contents(None)
 158
 159         self.assertTrue(succ)
 160         self.assertTrue(new_succ)
 161         self.assertEqual(etag, new_etag)
 162         self.assertEqual(content, new_content)
 163
 164     # https://bugzilla.gnome.org/show_bug.cgi?id=690525
 165     def disabled_test_replace_contents_async(self):
 166         content = b''.join(bytes(chr(i), 'utf-8') for i in range(128))
 167
 168         def callback(f, result, d):
 169             # Quit so in case of failed assertations loop doesn't keep running.
 170             main_loop.quit()
 171             succ, etag = self.file.replace_contents_finish(result)
 172             new_succ, new_content, new_etag = self.file.load_contents(None)
 173             d['succ'], d['etag'] = self.file.replace_contents_finish(result)
 174             load = self.file.load_contents(None)
 175             d['new_succ'], d['new_content'], d['new_etag'] = load
 176
 177         data = {}
 178         self.file.replace_contents_async(content, None, False,
 179                                          Gio.FileCreateFlags.NONE, None,
 180                                          callback, data)
 181         main_loop = GLib.MainLoop()
 182         main_loop.run()
 183         self.assertTrue(data['succ'])
 184         self.assertTrue(data['new_succ'])
 185         self.assertEqual(data['etag'], data['new_etag'])
 186         self.assertEqual(content, data['new_content'])
 187
 188     def test_tmp_exists(self):
 189         # A simple test to check if Gio.File.new_tmp is working correctly.
 190         self.assertTrue(self.file.query_exists(None))
 191
 192     def test_delete(self):
 193         self.file.delete(None)
 194         self.assertFalse(self.file.query_exists(None))
 195
 196     def test_delete_async(self):
 197         def callback(f, result, data):
 198             main_loop.quit()
 199
 200         self.file.delete_async(0, None, callback, None)
 201         main_loop = GLib.MainLoop()
 202         main_loop.run()
 203         self.assertFalse(self.file.query_exists(None))