lots more pylint fixes

1 files changed, 71 insertions, 76 deletions

diff --git a/nova/tests/network_unittest.py b/nova/tests/network_unittest.py
index 9aa39e516..5671a8886 100644
--- a/nova/tests/network_unittest.py
+++ b/nova/tests/network_unittest.py
@@ -15,7 +15,9 @@
 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 #    License for the specific language governing permissions and limitations
 #    under the License.
-
+"""
+Unit Tests for network code
+"""
 import IPy
 import os
 import logging
@@ -33,7 +35,8 @@ FLAGS = flags.FLAGS
 
 
 class NetworkTestCase(test.TrialTestCase):
-    def setUp(self):
+    """Test cases for network code"""
+    def setUp(self):  # pylint: disable=C0103
         super(NetworkTestCase, self).setUp()
         # NOTE(vish): if you change these flags, make sure to change the
         #             flags in the corresponding section in nova-dhcpbridge
@@ -44,7 +47,6 @@ class NetworkTestCase(test.TrialTestCase):
                    network_size=32)
         logging.getLogger().setLevel(logging.DEBUG)
         self.manager = manager.AuthManager()
-        self.dnsmasq = FakeDNSMasq()
         self.user = self.manager.create_user('netuser', 'netuser', 'netuser')
         self.projects = []
         self.projects.append(self.manager.create_project('netuser',
@@ -56,49 +58,48 @@ class NetworkTestCase(test.TrialTestCase):
                                                              'netuser',
                                                              name))
             vpn.NetworkData.create(self.projects[i].id)
-        self.network = model.PublicNetworkController()
         self.service = service.VlanNetworkService()
 
-    def tearDown(self):
+    def tearDown(self):  # pylint: disable=C0103
         super(NetworkTestCase, self).tearDown()
         for project in self.projects:
             self.manager.delete_project(project)
         self.manager.delete_user(self.user)
 
     def test_public_network_allocation(self):
+        """Makes sure that we can allocaate a public ip"""
         pubnet = IPy.IP(flags.FLAGS.public_range)
-        address = self.network.allocate_ip(self.user.id,
-                                           self.projects[0].id,
-                                           "public")
+        address = self.service.allocate_elastic_ip(self.user.id,
+                                           self.projects[0].id)
         self.assertTrue(IPy.IP(address) in pubnet)
-        self.assertTrue(IPy.IP(address) in self.network.network)
 
     def test_allocate_deallocate_fixed_ip(self):
+        """Makes sure that we can allocate and deallocate a fixed ip"""
         result = self.service.allocate_fixed_ip(
                 self.user.id, self.projects[0].id)
         address = result['private_dns_name']
         mac = result['mac_address']
-        logging.debug("Was allocated %s" % (address))
         net = model.get_project_network(self.projects[0].id, "default")
         self.assertEqual(True, is_in_project(address, self.projects[0].id))
         hostname = "test-host"
-        self.dnsmasq.issue_ip(mac, address, hostname, net.bridge_name)
-        rv = self.service.deallocate_fixed_ip(address)
+        issue_ip(mac, address, hostname, net.bridge_name)
+        self.service.deallocate_fixed_ip(address)
 
         # Doesn't go away until it's dhcp released
         self.assertEqual(True, is_in_project(address, self.projects[0].id))
 
-        self.dnsmasq.release_ip(mac, address, hostname, net.bridge_name)
+        release_ip(mac, address, hostname, net.bridge_name)
         self.assertEqual(False, is_in_project(address, self.projects[0].id))
 
-    def test_range_allocation(self):
-        hostname = "test-host"
-        result = self.service.allocate_fixed_ip(
-                    self.user.id, self.projects[0].id)
+    def test_side_effects(self):
+        """Ensures allocating and releasing has no side effects"""
+        hostname = "side-effect-host"
+        result = self.service.allocate_fixed_ip(self.user.id,
+                                                self.projects[0].id)
         mac = result['mac_address']
         address = result['private_dns_name']
-        result = self.service.allocate_fixed_ip(
-                self.user, self.projects[1].id)
+        result = self.service.allocate_fixed_ip(self.user,
+                                                self.projects[1].id)
         secondmac = result['mac_address']
         secondaddress = result['private_dns_name']
 
@@ -111,25 +112,24 @@ class NetworkTestCase(test.TrialTestCase):
         self.assertEqual(False, is_in_project(address, self.projects[1].id))
 
         # Addresses are allocated before they're issued
-        self.dnsmasq.issue_ip(mac, address, hostname, net.bridge_name)
-        self.dnsmasq.issue_ip(secondmac, secondaddress,
-                                hostname, secondnet.bridge_name)
+        issue_ip(mac, address, hostname, net.bridge_name)
+        issue_ip(secondmac, secondaddress, hostname, secondnet.bridge_name)
 
-        rv = self.service.deallocate_fixed_ip(address)
-        self.dnsmasq.release_ip(mac, address, hostname, net.bridge_name)
+        self.service.deallocate_fixed_ip(address)
+        release_ip(mac, address, hostname, net.bridge_name)
         self.assertEqual(False, is_in_project(address, self.projects[0].id))
 
         # First address release shouldn't affect the second
         self.assertEqual(True, is_in_project(secondaddress,
                                              self.projects[1].id))
 
-        rv = self.service.deallocate_fixed_ip(secondaddress)
-        self.dnsmasq.release_ip(secondmac, secondaddress,
-                                hostname, secondnet.bridge_name)
+        self.service.deallocate_fixed_ip(secondaddress)
+        release_ip(secondmac, secondaddress, hostname, secondnet.bridge_name)
         self.assertEqual(False, is_in_project(secondaddress,
                                               self.projects[1].id))
 
     def test_subnet_edge(self):
+        """Makes sure that private ips don't overlap"""
         result = self.service.allocate_fixed_ip(self.user.id,
                                                        self.projects[0].id)
         firstaddress = result['private_dns_name']
@@ -148,29 +148,34 @@ class NetworkTestCase(test.TrialTestCase):
                    self.user, project_id)
             mac3 = result['mac_address']
             address3 = result['private_dns_name']
+            net = model.get_project_network(project_id, "default")
+            issue_ip(mac, address, hostname, net.bridge_name)
+            issue_ip(mac2, address2, hostname, net.bridge_name)
+            issue_ip(mac3, address3, hostname, net.bridge_name)
             self.assertEqual(False, is_in_project(address,
                                                   self.projects[0].id))
             self.assertEqual(False, is_in_project(address2,
                                                   self.projects[0].id))
             self.assertEqual(False, is_in_project(address3,
                                                   self.projects[0].id))
-            rv = self.service.deallocate_fixed_ip(address)
-            rv = self.service.deallocate_fixed_ip(address2)
-            rv = self.service.deallocate_fixed_ip(address3)
-            net = model.get_project_network(project_id, "default")
-            self.dnsmasq.release_ip(mac, address, hostname, net.bridge_name)
-            self.dnsmasq.release_ip(mac2, address2, hostname, net.bridge_name)
-            self.dnsmasq.release_ip(mac3, address3, hostname, net.bridge_name)
+            self.service.deallocate_fixed_ip(address)
+            self.service.deallocate_fixed_ip(address2)
+            self.service.deallocate_fixed_ip(address3)
+            release_ip(mac, address, hostname, net.bridge_name)
+            release_ip(mac2, address2, hostname, net.bridge_name)
+            release_ip(mac3, address3, hostname, net.bridge_name)
         net = model.get_project_network(self.projects[0].id, "default")
-        rv = self.service.deallocate_fixed_ip(firstaddress)
-        self.dnsmasq.release_ip(mac, firstaddress, hostname, net.bridge_name)
+        self.service.deallocate_fixed_ip(firstaddress)
+        release_ip(mac, firstaddress, hostname, net.bridge_name)
 
     def test_vpn_ip_and_port_looks_valid(self):
+        """Ensure the vpn ip and port are reasonable"""
         self.assert_(self.projects[0].vpn_ip)
         self.assert_(self.projects[0].vpn_port >= FLAGS.vpn_start_port)
         self.assert_(self.projects[0].vpn_port <= FLAGS.vpn_end_port)
 
     def test_too_many_vpns(self):
+        """Ensure error is raised if we run out of vpn ports"""
         vpns = []
         for i in xrange(vpn.NetworkData.num_ports_for_ip(FLAGS.vpn_ip)):
             vpns.append(vpn.NetworkData.create("vpnuser%s" % i))
@@ -180,7 +185,6 @@ class NetworkTestCase(test.TrialTestCase):
 
     def test_ips_are_reused(self):
         """Makes sure that ip addresses that are deallocated get reused"""
-
         result = self.service.allocate_fixed_ip(
                     self.user.id, self.projects[0].id)
         mac = result['mac_address']
@@ -189,24 +193,18 @@ class NetworkTestCase(test.TrialTestCase):
         hostname = "reuse-host"
         net = model.get_project_network(self.projects[0].id, "default")
 
-        self.dnsmasq.issue_ip(mac, address, hostname, net.bridge_name)
-        rv = self.service.deallocate_fixed_ip(address)
-        self.dnsmasq.release_ip(mac, address, hostname, net.bridge_name)
+        issue_ip(mac, address, hostname, net.bridge_name)
+        self.service.deallocate_fixed_ip(address)
+        release_ip(mac, address, hostname, net.bridge_name)
 
         result = self.service.allocate_fixed_ip(
                 self.user, self.projects[0].id)
         secondmac = result['mac_address']
         secondaddress = result['private_dns_name']
         self.assertEqual(address, secondaddress)
-        rv = self.service.deallocate_fixed_ip(secondaddress)
-        self.dnsmasq.issue_ip(secondmac,
-                              secondaddress,
-                              hostname,
-                              net.bridge_name)
-        self.dnsmasq.release_ip(secondmac,
-                                secondaddress,
-                                hostname,
-                                net.bridge_name)
+        self.service.deallocate_fixed_ip(secondaddress)
+        issue_ip(secondmac, secondaddress, hostname, net.bridge_name)
+        release_ip(secondmac, secondaddress, hostname, net.bridge_name)
 
     def test_available_ips(self):
         """Make sure the number of available ips for the network is correct
@@ -242,47 +240,44 @@ class NetworkTestCase(test.TrialTestCase):
                                                     self.projects[0].id)
             macs[i] = result['mac_address']
             addresses[i] = result['private_dns_name']
-            self.dnsmasq.issue_ip(macs[i],
-                                  addresses[i],
-                                  hostname,
-                                  net.bridge_name)
+            issue_ip(macs[i], addresses[i], hostname, net.bridge_name)
 
         self.assertEqual(len(list(net.available)), 0)
         self.assertRaises(NoMoreAddresses, self.service.allocate_fixed_ip,
                           self.user.id, self.projects[0].id)
 
         for i in range(len(addresses)):
-            rv = self.service.deallocate_fixed_ip(addresses[i])
-            self.dnsmasq.release_ip(macs[i],
-                                    addresses[i],
-                                    hostname,
-                                    net.bridge_name)
+            self.service.deallocate_fixed_ip(addresses[i])
+            release_ip(macs[i], addresses[i], hostname, net.bridge_name)
         self.assertEqual(len(list(net.available)), num_available_ips)
 
 
 def is_in_project(address, project_id):
+    """Returns true if address is in specified project"""
     return address in model.get_project_network(project_id).list_addresses()
 
 
 def binpath(script):
+    """Returns the absolute path to a script in bin"""
     return os.path.abspath(os.path.join(__file__, "../../../bin", script))
 
 
-class FakeDNSMasq(object):
-    def issue_ip(self, mac, ip, hostname, interface):
-        cmd = "%s add %s %s %s" % (binpath('nova-dhcpbridge'),
-                                   mac, ip, hostname)
-        env = {'DNSMASQ_INTERFACE': interface,
-               'TESTING': '1',
-               'FLAGFILE': FLAGS.dhcpbridge_flagfile}
-        (out, err) = utils.execute(cmd, addl_env=env)
-        logging.debug("ISSUE_IP: %s, %s " % (out, err))
-
-    def release_ip(self, mac, ip, hostname, interface):
-        cmd = "%s del %s %s %s" % (binpath('nova-dhcpbridge'),
-                                   mac, ip, hostname)
-        env = {'DNSMASQ_INTERFACE': interface,
-               'TESTING': '1',
-               'FLAGFILE': FLAGS.dhcpbridge_flagfile}
-        (out, err) = utils.execute(cmd, addl_env=env)
-        logging.debug("RELEASE_IP: %s, %s " % (out, err))
+def issue_ip(mac, private_ip, hostname, interface):
+    """Run add command on dhcpbridge"""
+    cmd = "%s add %s %s %s" % (binpath('nova-dhcpbridge'),
+                               mac, private_ip, hostname)
+    env = {'DNSMASQ_INTERFACE': interface,
+           'TESTING': '1',
+           'FLAGFILE': FLAGS.dhcpbridge_flagfile}
+    (out, err) = utils.execute(cmd, addl_env=env)
+    logging.debug("ISSUE_IP: %s, %s ", out, err)
+
+def release_ip(mac, private_ip, hostname, interface):
+    """Run del command on dhcpbridge"""
+    cmd = "%s del %s %s %s" % (binpath('nova-dhcpbridge'),
+                               mac, private_ip, hostname)
+    env = {'DNSMASQ_INTERFACE': interface,
+           'TESTING': '1',
+           'FLAGFILE': FLAGS.dhcpbridge_flagfile}
+    (out, err) = utils.execute(cmd, addl_env=env)
+    logging.debug("RELEASE_IP: %s, %s ", out, err)