← Back to branch summary

~jonas-drange/ubuntu-system-settings/hotspots-binding

« back to all changes in this revision

Viewing changes to tests/autopilot/ubuntu_system_settings/tests/test_cellular.py

  • Committer: jonas-drange
  • Date: 2015-05-13 18:23:57 UTC
  • Revision ID: jonas.drange@canonical.com-20150513182357-r6gq7xofgk1pihya
style

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/autopilot/ubuntu_system_settings/tests/test_cellular.py
15
15
 
16
16
from ubuntu_system_settings.tests import (
17
17
    CellularBaseTestCase, HotspotBaseTestCase, CONNMAN_IFACE, RDO_IFACE,
18
 
    NETREG_IFACE)
 
18
    NETREG_IFACE, NM_IFACE, NM_AC_CON_IFACE, NM_PATH)
 
19
 
 
20
SETTINGS_CON_IFACE = 'org.freedesktop.NetworkManager.Settings.Connection'
 
21
DEV_IFACE = 'org.freedesktop.NetworkManager.Device'
19
22
 
20
23
 
21
24
class CellularTestCase(CellularBaseTestCase):
299
302
        password = 'abcdefgh'
300
303
        config = {'password': password}
301
304
        hotspot_page = self.cellular_page.setup_hotspot(config)
 
305
        active_connection = NM_PATH + 'ActiveConnection/0'
302
306
 
 
307
        # Assert that the switch is on.
303
308
        self.assertTrue(hotspot_page.get_hotspot_status())
304
309
 
305
310
        # Assert that Block on Urfkill is called twice.
306
 
        target_block_calls = 2
307
311
        self.assertThat(
308
312
            lambda: len(self.urfkill_mock.GetMethodCalls('Block')),
309
 
            Eventually(Equals(target_block_calls)))
 
313
            Eventually(Equals(2))
 
314
        )
310
315
 
311
 
        # Assert that we get one active connection
 
316
        # Assert that we get one active connection.
312
317
        self.assertThat(
313
 
            lambda: len(self.obj_nm.GetAll(
314
 
                'org.freedesktop.NetworkManager')['ActiveConnections']),
315
 
            Eventually(Equals(1)))
 
318
            lambda: len(self.obj_nm.GetAll(NM_IFACE)['ActiveConnections']),
 
319
            Eventually(Equals(1))
 
320
        )
316
321
 
317
322
        # Assert that the active connection has a certain path.
318
 
        active_connection = ('/org/freedesktop/NetworkManager/'
319
 
                             'ActiveConnection/0')
320
323
        self.assertThat(
321
 
            lambda: self.obj_nm.GetAll('org.freedesktop.NetworkManager')[
322
 
                'ActiveConnections'][0],
323
 
            Eventually(Equals(active_connection)))
 
324
            lambda: self.obj_nm.GetAll(NM_IFACE)['ActiveConnections'][0],
 
325
            Eventually(Equals(active_connection))
 
326
        )
324
327
 
325
328
        # Assert the device's active connection
326
329
        self.assertThat(
327
 
            lambda: self.device_mock.Get(
328
 
                'org.freedesktop.NetworkManager.Device', 'ActiveConnection'),
329
 
            Eventually(Equals(active_connection)))
 
330
            lambda: self.device_mock.Get(DEV_IFACE, 'ActiveConnection'),
 
331
            Eventually(Equals(active_connection))
 
332
        )
330
333
 
331
334
        active_connection_mock = dbus.Interface(self.dbus_con.get_object(
332
 
            'org.freedesktop.NetworkManager', active_connection),
 
335
            NM_IFACE, active_connection),
333
336
            'org.freedesktop.DBus.Properties')
334
337
 
335
 
        connection_path = active_connection_mock.Get(
336
 
            'org.freedesktop.NetworkManager.Connection.Active', 'Connection')
 
338
        connection_path = active_connection_mock.Get(NM_AC_CON_IFACE,
 
339
                                                     'Connection')
337
340
 
338
341
        connection_mock = dbus.Interface(self.dbus_con.get_object(
339
 
            'org.freedesktop.NetworkManager', connection_path),
340
 
            'org.freedesktop.NetworkManager.Settings.Connection')
 
342
            NM_IFACE, connection_path), SETTINGS_CON_IFACE)
341
343
 
342
344
        settings = connection_mock.GetSettings()
343
345
 
344
346
        # Assert that autoconnect is true, that ssid and password is what we
345
347
        # expect them to be.
346
348
        self.assertTrue(settings['connection']['autoconnect'])
347
 
        self.assertEqual(bytearray(
348
 
            settings['802-11-wireless']['ssid']).decode('utf-8'), ssid)
 
349
 
 
350
        s_ssid = bytearray(settings['802-11-wireless']['ssid']).decode('utf-8')
 
351
        self.assertEqual(s_ssid, ssid)
349
352
        self.assertEqual(settings['802-11-wireless-security']['psk'], password)
350
353
 
351
 
        # Now we change the settings
 
354
        # Now we change the settings.
352
355
        ssid = 'Bar'
353
356
        password = 'zomgzomg'
354
357
        config = {'ssid': ssid, 'password': password}
359
362
        # Assert that the ssid changed
360
363
        self.assertThat(
361
364
            lambda: bytearray(
362
 
                connection_mock.GetSettings()[
363
 
                    '802-11-wireless']['ssid']).decode('utf-8'),
364
 
            Eventually(Equals(ssid)))
 
365
                connection_mock.GetSettings()['802-11-wireless']
 
366
                                             ['ssid']).decode('utf-8'),
 
367
            Eventually(Equals(ssid))
 
368
        )
365
369
 
366
370
        self.cellular_page.disable_hotspot()
367
371
        self.assertFalse(hotspot_page.get_hotspot_status())
368
372
 
369
 
        # Assert that the active connection is removed
 
373
        # Assert that the active connection is removed.
370
374
        self.assertThat(
371
 
            lambda: len(self.obj_nm.GetAll(
372
 
                'org.freedesktop.NetworkManager')['ActiveConnections']),
373
 
            Eventually(Equals(0)))
 
375
            lambda: len(self.obj_nm.GetAll(NM_IFACE)['ActiveConnections']),
 
376
            Eventually(Equals(0))
 
377
        )