network: Convert tests to pytest style

Signed-off-by: Sunil Mohan Adapa <sunil@medhas.org>
Reviewed-by: Joseph Nuthalapati <njoseph@thoughtworks.com>

plinth/tests/test_network.py

@@ -20,14 +20,9 @@ Test module for network configuration utilities.
 """
 
 import copy
-import os
 import time
-import unittest
 
-
+import pytest
-euid = os.geteuid()
-if euid == 0:
-    from plinth import network
 
 ethernet_settings = {
     'common': {
@@ -88,57 +83,66 @@ pppoe_settings = {
     },
 }
 
+@pytest.fixture(name='network')
+def fixture_network(needs_root):
+    """Return the network module. Load it conservatively."""
+    from plinth import network as network_module
+    return network_module
 
-class TestNetwork(unittest.TestCase):
-    """Verify that the network module performs as expected."""
 
-    ethernet_uuid = None
+def _connection(network, settings):
-    wifi_uuid = None
+    """Create, yield and delete a connection."""
-    pppoe_uuid = None
+    uuid = network.add_connection(settings)
-
-    @classmethod
-    def setUp(cls):
-        cls.ethernet_uuid = network.add_connection(ethernet_settings)
-        cls.wifi_uuid = network.add_connection(wifi_settings)
-        cls.pppoe_uuid = network.add_connection(pppoe_settings)
-        # XXX: Handle this properly by waiting for asynchronous add_connection
-        # to complete.
     time.sleep(0.1)
+    yield uuid
+    network.delete_connection(uuid)
 
-    @classmethod
-    def tearDown(cls):
-        network.delete_connection(cls.ethernet_uuid)
-        network.delete_connection(cls.wifi_uuid)
-        network.delete_connection(cls.pppoe_uuid)
 
-    @unittest.skipUnless(euid == 0, 'Needs to be root')
+@pytest.fixture(name='ethernet_uuid')
-    def test_get_connection_list(self):
+def fixture_ethernet_uuid(network):
+    """Test fixture to setup and teardown an Ethernet connection."""
+    yield from _connection(network, ethernet_settings)
+
+
+@pytest.fixture(name='wifi_uuid')
+def fixture_wifi_uuid(network):
+    """Test fixture to setup and teardown an Wi-Fi connection."""
+    yield from _connection(network, wifi_settings)
+
+
+@pytest.fixture(name='pppoe_uuid')
+def fixture_pppoe_uuid(network):
+    """Test fixture to setup and teardown an PPPoE connection."""
+    yield from _connection(network, pppoe_settings)
+
+
+
+@pytest.mark.usefixtures('ethernet_uuid', 'wifi_uuid', 'pppoe_uuid')
+def test_get_connection_list(network):
     """Check that we can get a list of available connections."""
     connections = network.get_connection_list()
 
-        self.assertTrue('plinth_test_eth' in [x['name'] for x in connections])
+    assert 'plinth_test_eth' in [x['name'] for x in connections]
-        self.assertTrue('plinth_test_wifi' in [x['name'] for x in connections])
+    assert 'plinth_test_wifi' in [x['name'] for x in connections]
-        self.assertTrue('plinth_test_pppoe' in
+    assert 'plinth_test_pppoe' in [x['name'] for x in connections]
-                        [x['name'] for x in connections])
 
-    @unittest.skipUnless(euid == 0, 'Needs to be root')
+
-    def test_get_connection(self):
+
+def test_get_connection(network, ethernet_uuid, wifi_uuid):
     """Check that we can get a connection by name."""
-        connection = network.get_connection(self.ethernet_uuid)
+    connection = network.get_connection(ethernet_uuid)
-        self.assertEqual(
+    assert connection.get_id() == 'plinth_test_eth'
-            connection.get_id(), 'plinth_test_eth')
 
-        connection = network.get_connection(self.wifi_uuid)
+    connection = network.get_connection(wifi_uuid)
-        self.assertEqual(
+    assert connection.get_id() == 'plinth_test_wifi'
-            connection.get_id(), 'plinth_test_wifi')
 
-        self.assertRaises(network.ConnectionNotFound, network.get_connection,
+    with pytest.raises(network.ConnectionNotFound):
-                          'x-invalid-network-id')
+        network.get_connection('x-invalid-network-id')
 
-    @unittest.skipUnless(euid == 0, 'Needs to be root')
+
-    def test_edit_ethernet_connection(self):
+def test_edit_ethernet_connection(network, ethernet_uuid):
     """Check that we can update an ethernet connection."""
-        connection = network.get_connection(self.ethernet_uuid)
+    connection = network.get_connection(ethernet_uuid)
     ethernet_settings2 = copy.deepcopy(ethernet_settings)
     ethernet_settings2['common']['name'] = 'plinth_test_eth_new'
     ethernet_settings2['common']['interface'] = 'eth1'
@@ -146,20 +150,20 @@ class TestNetwork(unittest.TestCase):
     ethernet_settings2['ipv4']['method'] = 'auto'
     network.edit_connection(connection, ethernet_settings2)
 
-        connection = network.get_connection(self.ethernet_uuid)
+    connection = network.get_connection(ethernet_uuid)
-        self.assertEqual(connection.get_id(), 'plinth_test_eth_new')
+    assert connection.get_id() == 'plinth_test_eth_new'
 
     settings_connection = connection.get_setting_connection()
-        self.assertEqual(settings_connection.get_interface_name(), 'eth1')
+    assert settings_connection.get_interface_name() == 'eth1'
-        self.assertEqual(settings_connection.get_zone(), 'external')
+    assert settings_connection.get_zone() == 'external'
 
     settings_ipv4 = connection.get_setting_ip4_config()
-        self.assertEqual(settings_ipv4.get_method(), 'auto')
+    assert settings_ipv4.get_method() == 'auto'
 
-    @unittest.skipUnless(euid == 0, 'Needs to be root')
+
-    def test_edit_pppoe_connection(self):
+def test_edit_pppoe_connection(network, pppoe_uuid):
     """Check that we can update a PPPoE connection."""
-        connection = network.get_connection(self.ethernet_uuid)
+    connection = network.get_connection(pppoe_uuid)
     pppoe_settings2 = copy.deepcopy(pppoe_settings)
     pppoe_settings2['common']['name'] = 'plinth_test_pppoe_new'
     pppoe_settings2['common']['interface'] = 'eth2'
@@ -168,26 +172,26 @@ class TestNetwork(unittest.TestCase):
     pppoe_settings2['pppoe']['password'] = 'x-password-new'
     network.edit_connection(connection, pppoe_settings2)
 
-        connection = network.get_connection(self.ethernet_uuid)
+    connection = network.get_connection(pppoe_uuid)
-        self.assertEqual(connection.get_id(), 'plinth_test_pppoe_new')
+    assert connection.get_id() == 'plinth_test_pppoe_new'
 
     settings_connection = connection.get_setting_connection()
-        self.assertEqual(settings_connection.get_interface_name(), 'eth2')
+    assert settings_connection.get_interface_name() == 'eth2'
-        self.assertEqual(settings_connection.get_zone(), 'external')
+    assert settings_connection.get_zone() == 'external'
 
     settings_pppoe = connection.get_setting_pppoe()
-        self.assertEqual(settings_pppoe.get_username(), 'x-user-new')
+    assert settings_pppoe.get_username() == 'x-user-new'
     secrets = connection.get_secrets('pppoe')
-        self.assertEqual(secrets['pppoe']['password'], 'x-password-new')
+    assert secrets['pppoe']['password'] == 'x-password-new'
 
     settings_ppp = connection.get_setting_ppp()
-        self.assertEqual(settings_ppp.get_lcp_echo_failure(), 5)
+    assert settings_ppp.get_lcp_echo_failure() == 5
-        self.assertEqual(settings_ppp.get_lcp_echo_interval(), 30)
+    assert settings_ppp.get_lcp_echo_interval() == 30
 
-    @unittest.skipUnless(euid == 0, 'Needs to be root')
+
-    def test_edit_wifi_connection(self):
+def test_edit_wifi_connection(network, wifi_uuid):
     """Check that we can update a wifi connection."""
-        connection = network.get_connection(self.wifi_uuid)
+    connection = network.get_connection(wifi_uuid)
     wifi_settings2 = copy.deepcopy(wifi_settings)
     wifi_settings2['common']['name'] = 'plinth_test_wifi_new'
     wifi_settings2['common']['interface'] = 'wlan1'
@@ -199,31 +203,28 @@ class TestNetwork(unittest.TestCase):
     wifi_settings2['wireless']['passphrase'] = 'secretpassword'
     network.edit_connection(connection, wifi_settings2)
 
-        connection = network.get_connection(self.wifi_uuid)
+    connection = network.get_connection(wifi_uuid)
 
-        self.assertEqual(connection.get_id(), 'plinth_test_wifi_new')
+    assert connection.get_id() == 'plinth_test_wifi_new'
 
     settings_connection = connection.get_setting_connection()
-        self.assertEqual(settings_connection.get_interface_name(), 'wlan1')
+    assert settings_connection.get_interface_name() == 'wlan1'
-        self.assertEqual(settings_connection.get_zone(), 'external')
+    assert settings_connection.get_zone() == 'external'
 
     settings_wireless = connection.get_setting_wireless()
-        self.assertEqual(settings_wireless.get_ssid().get_data(),
+    assert settings_wireless.get_ssid().get_data() == b'plinthtestwifi2'
-                         b'plinthtestwifi2')
+    assert settings_wireless.get_mode() == 'infrastructure'
-        self.assertEqual(settings_wireless.get_mode(), 'infrastructure')
 
     wifi_sec = connection.get_setting_wireless_security()
-        self.assertEqual(wifi_sec.get_key_mgmt(), 'wpa-psk')
+    assert wifi_sec.get_key_mgmt() == 'wpa-psk'
 
     secrets = connection.get_secrets('802-11-wireless-security')
-        self.assertEqual(
+    assert secrets['802-11-wireless-security']['psk'] == 'secretpassword'
-            secrets['802-11-wireless-security']['psk'],
-            'secretpassword')
 
-    @unittest.skipUnless(euid == 0, 'Needs to be root')
+
-    def test_ethernet_manual_ipv4_address(self):
+def test_ethernet_manual_ipv4_address(network, ethernet_uuid):
     """Check that we can manually set IPv4 address on ethernet."""
-        connection = network.get_connection(self.ethernet_uuid)
+    connection = network.get_connection(ethernet_uuid)
     ethernet_settings2 = copy.deepcopy(ethernet_settings)
     ethernet_settings2['ipv4']['method'] = 'manual'
     ethernet_settings2['ipv4']['address'] = '169.254.0.1'
@@ -233,22 +234,22 @@ class TestNetwork(unittest.TestCase):
     ethernet_settings2['ipv4']['second_dns'] = '1.2.3.5'
     network.edit_connection(connection, ethernet_settings2)
 
-        connection = network.get_connection(self.ethernet_uuid)
+    connection = network.get_connection(ethernet_uuid)
     settings_ipv4 = connection.get_setting_ip4_config()
-        self.assertEqual(settings_ipv4.get_method(), 'manual')
+    assert settings_ipv4.get_method() == 'manual'
 
     address = settings_ipv4.get_address(0)
-        self.assertEqual(address.get_address(), '169.254.0.1')
+    assert address.get_address() == '169.254.0.1'
-        self.assertEqual(address.get_prefix(), 23)
+    assert address.get_prefix() == 23
-        self.assertEqual(settings_ipv4.get_gateway(), '169.254.0.254')
+    assert settings_ipv4.get_gateway() == '169.254.0.254'
-        self.assertEqual(settings_ipv4.get_num_dns(), 2)
+    assert settings_ipv4.get_num_dns() == 2
-        self.assertEqual(settings_ipv4.get_dns(0), '1.2.3.4')
+    assert settings_ipv4.get_dns(0) == '1.2.3.4'
-        self.assertEqual(settings_ipv4.get_dns(1), '1.2.3.5')
+    assert settings_ipv4.get_dns(1) == '1.2.3.5'
 
-    @unittest.skipUnless(euid == 0, 'Needs to be root')
+
-    def test_ethernet_manual_ipv6_address(self):
+def test_ethernet_manual_ipv6_address(network, ethernet_uuid):
     """Check that we can manually set IPv6 address on ethernet."""
-        connection = network.get_connection(self.ethernet_uuid)
+    connection = network.get_connection(ethernet_uuid)
     ethernet_settings2 = copy.deepcopy(ethernet_settings)
     ethernet_settings2['ipv6']['method'] = 'manual'
     ethernet_settings2['ipv6']['address'] = '::ffff:169.254.0.1'
@@ -258,22 +259,22 @@ class TestNetwork(unittest.TestCase):
     ethernet_settings2['ipv6']['second_dns'] = '::ffff:1.2.3.5'
     network.edit_connection(connection, ethernet_settings2)
 
-        connection = network.get_connection(self.ethernet_uuid)
+    connection = network.get_connection(ethernet_uuid)
     settings_ipv6 = connection.get_setting_ip6_config()
-        self.assertEqual(settings_ipv6.get_method(), 'manual')
+    assert settings_ipv6.get_method() == 'manual'
 
     address = settings_ipv6.get_address(0)
-        self.assertEqual(address.get_address(), '::ffff:169.254.0.1')
+    assert address.get_address() == '::ffff:169.254.0.1'
-        self.assertEqual(address.get_prefix(), 63)
+    assert address.get_prefix() == 63
-        self.assertEqual(settings_ipv6.get_gateway(), '::ffff:169.254.0.254')
+    assert settings_ipv6.get_gateway() == '::ffff:169.254.0.254'
-        self.assertEqual(settings_ipv6.get_num_dns(), 2)
+    assert settings_ipv6.get_num_dns() == 2
-        self.assertEqual(settings_ipv6.get_dns(0), '::ffff:1.2.3.4')
+    assert settings_ipv6.get_dns(0) == '::ffff:1.2.3.4'
-        self.assertEqual(settings_ipv6.get_dns(1), '::ffff:1.2.3.5')
+    assert settings_ipv6.get_dns(1) == '::ffff:1.2.3.5'
 
-    @unittest.skipUnless(euid == 0, 'Needs to be root')
+
-    def test_wifi_manual_ipv4_address(self):
+def test_wifi_manual_ipv4_address(network, wifi_uuid):
     """Check that we can manually set IPv4 address on wifi."""
-        connection = network.get_connection(self.wifi_uuid)
+    connection = network.get_connection(wifi_uuid)
     wifi_settings2 = copy.deepcopy(wifi_settings)
     wifi_settings2['ipv4']['method'] = 'manual'
     wifi_settings2['ipv4']['address'] = '169.254.0.2'
@@ -286,22 +287,22 @@ class TestNetwork(unittest.TestCase):
     wifi_settings2['wireless']['auth_mode'] = 'open'
     network.edit_connection(connection, wifi_settings2)
 
-        connection = network.get_connection(self.wifi_uuid)
+    connection = network.get_connection(wifi_uuid)
     settings_ipv4 = connection.get_setting_ip4_config()
-        self.assertEqual(settings_ipv4.get_method(), 'manual')
+    assert settings_ipv4.get_method() == 'manual'
 
     address = settings_ipv4.get_address(0)
-        self.assertEqual(address.get_address(), '169.254.0.2')
+    assert address.get_address() == '169.254.0.2'
-        self.assertEqual(address.get_prefix(), 23)
+    assert address.get_prefix() == 23
-        self.assertEqual(settings_ipv4.get_gateway(), '169.254.0.254')
+    assert settings_ipv4.get_gateway() == '169.254.0.254'
-        self.assertEqual(settings_ipv4.get_num_dns(), 2)
+    assert settings_ipv4.get_num_dns() == 2
-        self.assertEqual(settings_ipv4.get_dns(0), '1.2.3.4')
+    assert settings_ipv4.get_dns(0) == '1.2.3.4'
-        self.assertEqual(settings_ipv4.get_dns(1), '1.2.3.5')
+    assert settings_ipv4.get_dns(1) == '1.2.3.5'
 
-    @unittest.skipUnless(euid == 0, 'Needs to be root')
+
-    def test_wifi_manual_ipv6_address(self):
+def test_wifi_manual_ipv6_address(network, wifi_uuid):
     """Check that we can manually set IPv6 address on wifi."""
-        connection = network.get_connection(self.wifi_uuid)
+    connection = network.get_connection(wifi_uuid)
     wifi_settings2 = copy.deepcopy(wifi_settings)
     wifi_settings2['ipv6']['method'] = 'manual'
     wifi_settings2['ipv6']['address'] = '::ffff:169.254.0.2'
@@ -314,14 +315,14 @@ class TestNetwork(unittest.TestCase):
     wifi_settings2['wireless']['auth_mode'] = 'open'
     network.edit_connection(connection, wifi_settings2)
 
-        connection = network.get_connection(self.wifi_uuid)
+    connection = network.get_connection(wifi_uuid)
     settings_ipv6 = connection.get_setting_ip6_config()
-        self.assertEqual(settings_ipv6.get_method(), 'manual')
+    assert settings_ipv6.get_method() == 'manual'
 
     address = settings_ipv6.get_address(0)
-        self.assertEqual(address.get_address(), '::ffff:169.254.0.2')
+    assert address.get_address() == '::ffff:169.254.0.2'
-        self.assertEqual(address.get_prefix(), 63)
+    assert address.get_prefix() == 63
-        self.assertEqual(settings_ipv6.get_gateway(), '::ffff:169.254.0.254')
+    assert settings_ipv6.get_gateway() == '::ffff:169.254.0.254'
-        self.assertEqual(settings_ipv6.get_num_dns(), 2)
+    assert settings_ipv6.get_num_dns() == 2
-        self.assertEqual(settings_ipv6.get_dns(0), '::ffff:1.2.3.4')
+    assert settings_ipv6.get_dns(0) == '::ffff:1.2.3.4'
-        self.assertEqual(settings_ipv6.get_dns(1), '::ffff:1.2.3.5')
+    assert settings_ipv6.get_dns(1) == '::ffff:1.2.3.5'