pylint cleanup of tests

3 files changed, 50 insertions, 59 deletions

diff --git a/nova/tests/compute_unittest.py b/nova/tests/compute_unittest.py
index 0166dc4be..867b572f3 100644
--- a/nova/tests/compute_unittest.py
+++ b/nova/tests/compute_unittest.py
@@ -15,11 +15,12 @@
 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 #    License for the specific language governing permissions and limitations
 #    under the License.
-
+"""
+Tests For Compute
+"""
 import logging
-import time
+
 from twisted.internet import defer
-from xml.etree import ElementTree
 
 from nova import db
 from nova import exception
@@ -32,58 +33,39 @@ from nova.auth import manager
 FLAGS = flags.FLAGS
 
 
-class InstanceXmlTestCase(test.TrialTestCase):
-    # @defer.inlineCallbacks
-    def test_serialization(self):
-        # TODO: Reimplement this, it doesn't make sense in redis-land
-        return
-
-        # instance_id = 'foo'
-        # first_node = node.Node()
-        # inst = yield first_node.run_instance(self.context, instance_id)
-        #
-        # # force the state so that we can verify that it changes
-        # inst._s['state'] = node.Instance.NOSTATE
-        # xml = inst.toXml()
-        # self.assert_(ElementTree.parse(StringIO.StringIO(xml)))
-        #
-        # second_node = node.Node()
-        # new_inst = node.Instance.fromXml(second_node._conn,
-        #                                  pool=second_node._pool, xml=xml)
-        # self.assertEqual(new_inst.state, node.Instance.RUNNING)
-        # rv = yield first_node.terminate_instance(self.context, instance_id)
-
-
-class ComputeConnectionTestCase(test.TrialTestCase):
-    def setUp(self):
+class ComputeTestCase(test.TrialTestCase):
+    """Test case for compute"""
+    def setUp(self):  # pylint: disable-msg=C0103
         logging.getLogger().setLevel(logging.DEBUG)
-        super(ComputeConnectionTestCase, self).setUp()
+        super(ComputeTestCase, self).setUp()
         self.flags(connection_type='fake',
                    fake_storage=True)
         self.compute = utils.import_object(FLAGS.compute_manager)
         self.manager = manager.AuthManager()
-        user = self.manager.create_user('fake', 'fake', 'fake')
-        project = self.manager.create_project('fake', 'fake', 'fake')
+        self.user = self.manager.create_user('fake', 'fake', 'fake')
+        self.project = self.manager.create_project('fake', 'fake', 'fake')
         self.context = None
 
-    def tearDown(self):
-        self.manager.delete_user('fake')
-        self.manager.delete_project('fake')
+    def tearDown(self):  # pylint: disable-msg=C0103
+        self.manager.delete_user(self.user)
+        self.manager.delete_project(self.project)
 
     def _create_instance(self):
+        """Create a test instance"""
         inst = {}
         inst['image_id'] = 'ami-test'
         inst['reservation_id'] = 'r-fakeres'
         inst['launch_time'] = '10'
-        inst['user_id'] = 'fake'
-        inst['project_id'] = 'fake'
+        inst['user_id'] = self.user.id
+        inst['project_id'] = self.project.id
         inst['instance_type'] = 'm1.tiny'
         inst['mac_address'] = utils.generate_mac()
         inst['ami_launch_index'] = 0
         return db.instance_create(None, inst)
 
     @defer.inlineCallbacks
-    def test_run_describe_terminate(self):
+    def test_run_terminate(self):
+        """Make sure it is possible to  run and terminate instance"""
         instance_id = self._create_instance()
 
         yield self.compute.run_instance(self.context, instance_id)
@@ -100,6 +82,7 @@ class ComputeConnectionTestCase(test.TrialTestCase):
 
     @defer.inlineCallbacks
     def test_reboot(self):
+        """Ensure instance can be rebooted"""
         instance_id = self._create_instance()
         yield self.compute.run_instance(self.context, instance_id)
         yield self.compute.reboot_instance(self.context, instance_id)
@@ -107,16 +90,18 @@ class ComputeConnectionTestCase(test.TrialTestCase):
 
     @defer.inlineCallbacks
     def test_console_output(self):
+        """Make sure we can get console output from instance"""
         instance_id = self._create_instance()
-        rv = yield self.compute.run_instance(self.context, instance_id)
+        yield self.compute.run_instance(self.context, instance_id)
 
         console = yield self.compute.get_console_output(self.context,
                                                         instance_id)
         self.assert_(console)
-        rv = yield self.compute.terminate_instance(self.context, instance_id)
+        yield self.compute.terminate_instance(self.context, instance_id)
 
     @defer.inlineCallbacks
     def test_run_instance_existing(self):
+        """Ensure failure when running an instance that already exists"""
         instance_id = self._create_instance()
         yield self.compute.run_instance(self.context, instance_id)
         self.assertFailure(self.compute.run_instance(self.context,
diff --git a/nova/tests/network_unittest.py b/nova/tests/network_unittest.py
index fccfc23fb..7cd20dfcd 100644
--- a/nova/tests/network_unittest.py
+++ b/nova/tests/network_unittest.py
@@ -75,6 +75,7 @@ class NetworkTestCase(test.TrialTestCase):
         self.manager.delete_user(self.user)
 
     def _create_address(self, project_num, instance_id=None):
+        """Create an address in given project num"""
         net = db.project_get_network(None, self.projects[project_num].id)
         address = db.fixed_ip_allocate(None, net['id'])
         if instance_id is None:
@@ -147,7 +148,6 @@ class NetworkTestCase(test.TrialTestCase):
         first = self._create_address(0)
         lease_ip(first)
         for i in range(1, 5):
-            project_id = self.projects[i].id
             address = self._create_address(i)
             address2 = self._create_address(i)
             address3 = self._create_address(i)
@@ -227,7 +227,6 @@ class NetworkTestCase(test.TrialTestCase):
                                                            network['id'])
         addresses = []
         for i in range(num_available_ips):
-            project_id = self.projects[0].id
             address = self._create_address(0)
             addresses.append(address)
             lease_ip(address)
diff --git a/nova/tests/volume_unittest.py b/nova/tests/volume_unittest.py
index f42d0ac8d..0df0c20d6 100644
--- a/nova/tests/volume_unittest.py
+++ b/nova/tests/volume_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.
-
+"""
+Tests for Volume Code
+"""
 import logging
 
 from twisted.internet import defer
@@ -30,7 +32,8 @@ FLAGS = flags.FLAGS
 
 
 class VolumeTestCase(test.TrialTestCase):
-    def setUp(self):
+    """Test Case for volumes"""
+    def setUp(self):  # pylint: disable-msg=C0103
         logging.getLogger().setLevel(logging.DEBUG)
         super(VolumeTestCase, self).setUp()
         self.compute = utils.import_object(FLAGS.compute_manager)
@@ -39,9 +42,11 @@ class VolumeTestCase(test.TrialTestCase):
         self.volume = utils.import_object(FLAGS.volume_manager)
         self.context = None
 
-    def _create_volume(self, size='0'):
+    @staticmethod
+    def _create_volume(size='0'):
+        """Create a volume object"""
         vol = {}
-        vol['size'] = '0'
+        vol['size'] = size
         vol['user_id'] = 'fake'
         vol['project_id'] = 'fake'
         vol['availability_zone'] = FLAGS.storage_availability_zone
@@ -50,7 +55,8 @@ class VolumeTestCase(test.TrialTestCase):
         return db.volume_create(None, vol)['id']
 
     @defer.inlineCallbacks
-    def test_run_create_volume(self):
+    def test_create_delete_volume(self):
+        """Test volume can be created and deleted"""
         volume_id = self._create_volume()
         yield self.volume.create_volume(self.context, volume_id)
         self.assertEqual(volume_id, db.volume_get(None, volume_id).id)
@@ -63,6 +69,7 @@ class VolumeTestCase(test.TrialTestCase):
 
     @defer.inlineCallbacks
     def test_too_big_volume(self):
+        """Ensure failure if a too large of a volume is requested"""
         # FIXME(vish): validation needs to move into the data layer in
         #              volume_create
         defer.returnValue(True)
@@ -75,9 +82,10 @@ class VolumeTestCase(test.TrialTestCase):
 
     @defer.inlineCallbacks
     def test_too_many_volumes(self):
+        """Ensure that NoMoreBlades is raised when we run out of volumes"""
         vols = []
         total_slots = FLAGS.num_shelves * FLAGS.blades_per_shelf
-        for i in xrange(total_slots):
+        for _index in xrange(total_slots):
             volume_id = self._create_volume()
             yield self.volume.create_volume(self.context, volume_id)
             vols.append(volume_id)
@@ -91,7 +99,7 @@ class VolumeTestCase(test.TrialTestCase):
 
     @defer.inlineCallbacks
     def test_run_attach_detach_volume(self):
-        # Create one volume and one compute to test with
+        """Make sure volume can be attached and detached from instance"""
         instance_id = "storage-test"
         mountpoint = "/dev/sdf"
         volume_id = self._create_volume()
@@ -99,9 +107,9 @@ class VolumeTestCase(test.TrialTestCase):
         if FLAGS.fake_tests:
             db.volume_attached(None, volume_id, instance_id, mountpoint)
         else:
-            rv = yield self.compute.attach_volume(instance_id,
-                                                  volume_id,
-                                                  mountpoint)
+            yield self.compute.attach_volume(instance_id,
+                                             volume_id,
+                                             mountpoint)
         vol = db.volume_get(None, volume_id)
         self.assertEqual(vol['status'], "in-use")
         self.assertEqual(vol['attach_status'], "attached")
@@ -113,12 +121,12 @@ class VolumeTestCase(test.TrialTestCase):
         if FLAGS.fake_tests:
             db.volume_detached(None, volume_id)
         else:
-            rv = yield self.compute.detach_volume(instance_id,
-                                                 volume_id)
+            yield self.compute.detach_volume(instance_id,
+                                             volume_id)
         vol = db.volume_get(None, volume_id)
         self.assertEqual(vol['status'], "available")
 
-        rv = self.volume.delete_volume(self.context, volume_id)
+        yield self.volume.delete_volume(self.context, volume_id)
         self.assertRaises(exception.Error,
                           db.volume_get,
                           None,
@@ -126,23 +134,22 @@ class VolumeTestCase(test.TrialTestCase):
 
     @defer.inlineCallbacks
     def test_concurrent_volumes_get_different_blades(self):
-        vol_size = "5"
-        user_id = "fake"
-        project_id = 'fake'
-        shelf_blades = []
+        """Ensure multiple concurrent volumes get different blades"""
         volume_ids = []
+        shelf_blades = []
 
         def _check(volume_id):
+            """Make sure blades aren't duplicated"""
             volume_ids.append(volume_id)
             (shelf_id, blade_id) = db.volume_get_shelf_and_blade(None,
                                                                  volume_id)
             shelf_blade = '%s.%s' % (shelf_id, blade_id)
             self.assert_(shelf_blade not in shelf_blades)
             shelf_blades.append(shelf_blade)
-            logging.debug("got %s" % shelf_blade)
+            logging.debug("Blade %s allocated", shelf_blade)
         deferreds = []
         total_slots = FLAGS.num_shelves * FLAGS.blades_per_shelf
-        for i in range(total_slots):
+        for _index in xrange(total_slots):
             volume_id = self._create_volume()
             d = self.volume.create_volume(self.context, volume_id)
             d.addCallback(_check)