← Back to branch summary

~elementary-os/ubuntu-package-imports/ubiquity-bionic

« back to all changes in this revision

Viewing changes to tests/test_gtkwidgets.py

  • Committer: RabbitBot
  • Date: 2018-02-05 14:44:42 UTC
  • Revision ID: rabbitbot@elementary.io-20180205144442-vt0fvth7zus90wjh
Initial import, version 17.10.10

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_gtkwidgets.py
 
1
#!/usr/bin/python3
 
2
# -*- coding: utf-8; -*-
 
3
 
 
4
import sys
 
5
from test.support import run_unittest
 
6
import unittest
 
7
 
 
8
import dbus
 
9
from gi.repository import Gtk, TimezoneMap
 
10
import mock
 
11
 
 
12
from ubiquity import gtkwidgets, nm, segmented_bar
 
13
from ubiquity.frontend.gtk_components import nmwidgets
 
14
 
 
15
 
 
16
class MockController(object):
 
17
    def get_string(self, name, lang=None, prefix=None):
 
18
        return "%s: %s" % (lang, name)
 
19
 
 
20
 
 
21
class WidgetTests(unittest.TestCase):
 
22
    def setUp(self):
 
23
        self.err = None
 
24
 
 
25
        def excepthook(exctype, value, tb):
 
26
            # Workaround for http://bugzilla.gnome.org/show_bug.cgi?id=616279
 
27
            Gtk.main_quit()
 
28
            self.err = exctype, value, tb
 
29
 
 
30
        sys.excepthook = excepthook
 
31
        self.win = Gtk.Window()
 
32
 
 
33
    def tearDown(self):
 
34
        self.win.hide()
 
35
        if self.err:
 
36
            exctype, value, tb = self.err
 
37
            if value.__traceback__ is not tb:
 
38
                raise value.with_traceback(tb)
 
39
            else:
 
40
                raise value
 
41
 
 
42
    def test_segmented_bar(self):
 
43
        sb = segmented_bar.SegmentedBar()
 
44
        self.win.add(sb)
 
45
        sb.add_segment_rgb('Test One', 30 * 1000 * 1000 * 1000, 'ff00ff')
 
46
        sb.add_segment_rgb('Test Two', 30 * 1000 * 1000 * 1000, '0000ff')
 
47
        for segment in sb.segments:
 
48
            self.assertEqual(segment.subtitle, '30.0 GB')
 
49
        self.assertEqual(sb.segments[0].title, 'Test One')
 
50
        self.assertEqual(sb.segments[1].title, 'Test Two')
 
51
        sb.remove_all()
 
52
        self.assertEqual(sb.segments, [])
 
53
        self.win.show_all()
 
54
        gtkwidgets.refresh()
 
55
 
 
56
    def test_timezone_map(self):
 
57
        tzmap = TimezoneMap.TimezoneMap()
 
58
        self.win.add(tzmap)
 
59
        # tzmap.select_city('America/New_York')
 
60
        self.win.show_all()
 
61
        self.win.connect('destroy', Gtk.main_quit)
 
62
        gtkwidgets.refresh()
 
63
 
 
64
    def test_state_box(self):
 
65
        sb = gtkwidgets.StateBox('foobar')
 
66
        self.assertEqual(sb.get_property('label'), 'foobar')
 
67
        sb.set_property('label', 'barfoo')
 
68
        self.assertEqual(sb.get_property('label'), 'barfoo')
 
69
        sb.set_state(True)
 
70
        self.assertEqual(sb.image.get_stock(),
 
71
                         ('gtk-yes', Gtk.IconSize.LARGE_TOOLBAR))
 
72
        self.assertEqual(sb.get_state(), True)
 
73
        sb.set_state(False)
 
74
        self.assertEqual(sb.image.get_stock(),
 
75
                         ('gtk-no', Gtk.IconSize.LARGE_TOOLBAR))
 
76
        self.assertEqual(sb.get_state(), False)
 
77
 
 
78
    def test_gtk_to_cairo_color(self):
 
79
        self.assertEqual(gtkwidgets.gtk_to_cairo_color('white'),
 
80
                         (1.0, 1.0, 1.0))
 
81
        self.assertEqual(gtkwidgets.gtk_to_cairo_color('black'), (0, 0, 0))
 
82
        # After all these years a discrepancy between X11 green and CSS
 
83
        # green was noticed
 
84
        self.assertEqual(gtkwidgets.gtk_to_cairo_color('#00ff00'), (0, 1.0, 0))
 
85
        self.assertEqual(gtkwidgets.gtk_to_cairo_color('red'), (1.0, 0, 0))
 
86
        self.assertEqual(gtkwidgets.gtk_to_cairo_color('blue'), (0, 0, 1.0))
 
87
 
 
88
 
 
89
class NetworkStoreTests(unittest.TestCase):
 
90
    def setUp(self):
 
91
        self.model = nmwidgets.GtkNetworkStore()
 
92
 
 
93
    def test_add_device(self):
 
94
        self.model.add_device('/foo', 'Intel', 'Wireless')
 
95
        device_it = self.model.get_iter_first()
 
96
        self.assertEqual(self.model.get(device_it, 0, 1, 2),
 
97
                         ('/foo', 'Intel', 'Wireless'))
 
98
 
 
99
    def test_has_device(self):
 
100
        self.model.add_device('/foo', 'Intel', 'Wireless')
 
101
        self.model.add_device('/bar', 'Intel', 'Wireless')
 
102
 
 
103
        self.assert_(self.model.has_device('/foo'))
 
104
        self.assert_(not self.model.has_device('/not-there'))
 
105
 
 
106
    def test_get_device_ids(self):
 
107
        self.model.add_device('/foo', 'Intel', 'Wireless')
 
108
        self.model.add_device('/bar', 'Intel', 'Wireless')
 
109
 
 
110
        lst = self.model.get_device_ids()
 
111
        self.assertListEqual(lst, ['/foo', '/bar'])
 
112
 
 
113
    def test_add_ap(self):
 
114
        self.model.add_device('/foo', 'Intel', 'Wireless')
 
115
        self.model.add_ap('/foo', 'Orange', True, 40)
 
116
        self.model.add_ap('/foo', 'Apple', False, 60)
 
117
        device_it = self.model.get_iter_first()
 
118
 
 
119
        ap_it = self.model.iter_children(device_it)
 
120
        self.assert_(ap_it)
 
121
        self.assertEqual(self.model.get(ap_it, 0, 1, 2), ('Orange', True, 40))
 
122
 
 
123
        ap_it = self.model.iter_next(ap_it)
 
124
        self.assert_(ap_it)
 
125
        self.assertEqual(self.model.get(ap_it, 0, 1, 2), ('Apple', False, 60))
 
126
 
 
127
        ap_it = self.model.iter_next(ap_it)
 
128
        self.assert_(not ap_it)
 
129
 
 
130
    def test_has_ap(self):
 
131
        self.model.add_device('/foo', 'Intel', 'Wireless')
 
132
        self.model.add_ap('/foo', 'Orange', True, 40)
 
133
        self.model.add_ap('/foo', 'Apple', False, 60)
 
134
 
 
135
        self.assert_(self.model.has_ap('/foo', 'Orange'))
 
136
        self.assert_(not self.model.has_ap('/not-there', 'Orange'))
 
137
        self.assert_(not self.model.has_ap('/foo', 'Aubergine'))
 
138
 
 
139
    def test_set_ap_strength(self):
 
140
        self.model.add_device('/foo', 'Intel', 'Wireless')
 
141
        self.model.add_ap('/foo', 'Orange', True, 40)
 
142
 
 
143
        self.model.set_ap_strength('/foo', 'Orange', 80)
 
144
        device_it = self.model.get_iter_first()
 
145
        ap_it = self.model.iter_children(device_it)
 
146
        self.assertEqual(self.model[ap_it][2], 80)
 
147
 
 
148
    def test_remove_aps_not_in(self):
 
149
        def list_aps():
 
150
            device_it = self.model.get_iter_first()
 
151
            ap_it = self.model.iter_children(device_it)
 
152
            ret = []
 
153
            while ap_it:
 
154
                ret.append(self.model[ap_it][0])
 
155
                ap_it = self.model.iter_next(ap_it)
 
156
            return ret
 
157
 
 
158
        self.model.add_device('/foo', 'Intel', 'Wireless')
 
159
        fruits = ['Orange', 'Apple', 'Grape']
 
160
        for ssid in fruits:
 
161
            self.model.add_ap('/foo', ssid, True, 0)
 
162
 
 
163
        self.model.remove_aps_not_in('/foo', fruits)
 
164
        ret = list_aps()
 
165
        # There haven't been any changes in this update.
 
166
        self.assertListEqual(fruits, ret)
 
167
 
 
168
        # An AP that was present no longer is.
 
169
        fruits.pop()
 
170
        self.model.remove_aps_not_in('/foo', fruits)
 
171
        ret = list_aps()
 
172
        self.assertListEqual(fruits, ret)
 
173
 
 
174
 
 
175
udevinfo = """
 
176
UDEV_LOG=3
 
177
DEVPATH=/devices/pci0000:00/0000:00:1c.1/0000:03:00.0/net/wlan0
 
178
DEVTYPE=wlan
 
179
INTERFACE=wlan0
 
180
IFINDEX=3
 
181
SUBSYSTEM=net
 
182
ID_VENDOR_FROM_DATABASE=Intel Corporation
 
183
ID_MODEL_FROM_DATABASE=PRO/Wireless 3945ABG [Golan] Network Connection
 
184
ID_BUS=pci
 
185
ID_VENDOR_ID=0x8086
 
186
ID_MODEL_ID=0x4227
 
187
ID_MM_CANDIDATE=1
 
188
"""
 
189
 
 
190
 
 
191
class NetworkManagerTests(unittest.TestCase):
 
192
    def setUp(self):
 
193
        patcher = mock.patch('ubiquity.nm.NetworkManager.start')
 
194
        patcher.start()
 
195
        self.addCleanup(patcher.stop)
 
196
        self.model = nmwidgets.GtkNetworkStore()
 
197
        self.manager = nm.NetworkManager(self.model,
 
198
                                         nmwidgets.GLibQueuedCaller)
 
199
 
 
200
    @mock.patch('subprocess.Popen')
 
201
    def test_get_vendor_and_model_null(self, mock_subprocess):
 
202
        mock_subprocess.return_value.communicate.return_value = (
 
203
            '', 'device path not found\n')
 
204
        self.assertEqual(nm.get_vendor_and_model('bogus'), ('', ''))
 
205
 
 
206
    @mock.patch('subprocess.Popen')
 
207
    def test_get_vendor_and_model(self, mock_subprocess):
 
208
        mock_subprocess.return_value.communicate.return_value = (
 
209
            udevinfo, None)
 
210
        self.assertEqual(nm.get_vendor_and_model('foobar'),
 
211
                         ('Intel Corporation',
 
212
                          'PRO/Wireless 3945ABG [Golan] Network Connection'))
 
213
 
 
214
    def test_decode_ssid(self):
 
215
        ssid = [dbus.Byte(85), dbus.Byte(98), dbus.Byte(117), dbus.Byte(110),
 
216
                dbus.Byte(116), dbus.Byte(117), dbus.Byte(45), dbus.Byte(66),
 
217
                dbus.Byte(97), dbus.Byte(116), dbus.Byte(116), dbus.Byte(101),
 
218
                dbus.Byte(114), dbus.Byte(115), dbus.Byte(101), dbus.Byte(97)]
 
219
        self.assertEqual(nm.decode_ssid(ssid), 'Ubuntu-Battersea')
 
220
 
 
221
    def test_decode_ssid_utf8(self):
 
222
        ssid = [dbus.Byte(82), dbus.Byte(195), dbus.Byte(169), dbus.Byte(115),
 
223
                dbus.Byte(101), dbus.Byte(97), dbus.Byte(117)]
 
224
        self.assertEqual(nm.decode_ssid(ssid), 'Réseau')
 
225
 
 
226
    def test_decode_ssid_latin1(self):
 
227
        ssid = [dbus.Byte(82), dbus.Byte(233), dbus.Byte(115), dbus.Byte(101),
 
228
                dbus.Byte(97), dbus.Byte(117)]
 
229
        self.assertEqual(nm.decode_ssid(ssid), 'R\ufffdseau')
 
230
 
 
231
    def test_pixbuf_func(self):
 
232
        iterator = self.model.append(None, ['/foo', 'Intel', 'Wireless'])
 
233
        mock_cell = mock.Mock()
 
234
        tv = nmwidgets.NetworkManagerTreeView()
 
235
        tv.pixbuf_func(None, mock_cell, self.model, iterator, None)
 
236
        mock_cell.set_property.assert_called_with('pixbuf', None)
 
237
        # 0% strength, protected network
 
238
        i = self.model.append(iterator, ['Orange', True, 0])
 
239
        tv.pixbuf_func(None, mock_cell, self.model, i, None)
 
240
        mock_cell.set_property.assert_called_with('pixbuf', tv.icons[5])
 
241
        # 30% strength, protected network
 
242
        self.model.set_value(i, 2, 30)
 
243
        tv.pixbuf_func(None, mock_cell, self.model, i, None)
 
244
        mock_cell.set_property.assert_called_with('pixbuf', tv.icons[6])
 
245
        # 95% strength, unprotected network
 
246
        self.model.set_value(i, 1, False)
 
247
        self.model.set_value(i, 2, 95)
 
248
        tv.pixbuf_func(None, mock_cell, self.model, i, None)
 
249
        mock_cell.set_property.assert_called_with('pixbuf', tv.icons[4])
 
250
 
 
251
    def test_data_func(self):
 
252
        iterator = self.model.append(None, ['/foo', 'Intel', 'Wireless'])
 
253
        mock_cell = mock.Mock()
 
254
        tv = nmwidgets.NetworkManagerTreeView()
 
255
        tv.data_func(None, mock_cell, self.model, iterator, None)
 
256
        mock_cell.set_property.assert_called_with('text', 'Intel Wireless')
 
257
        i = self.model.append(iterator, ['Orange', True, 0])
 
258
        tv.data_func(None, mock_cell, self.model, i, None)
 
259
        mock_cell.set_property.assert_called_with('text', 'Orange')
 
260
 
 
261
 
 
262
if __name__ == '__main__':
 
263
    run_unittest(WidgetTests, NetworkStoreTests, NetworkManagerTests)