Use more specific asserts in tests

Instead of assertTrue and assertFalse use more specific asserts.
They are compatible with Python 2.7[1] and 3.4[2]

[1]: https://docs.python.org/2.7/library/unittest.html
[2]: https://docs.python.org/3.4/library/unittest.html

Change-Id: I448fd5b5604c1a7304f72819ea671b5fca4fee2e

ceilometer/tests/functional/api/v2/test_complex_query_scenarios.py

@@ -102,7 +102,7 @@ class TestQueryMetersController(tests_api.FunctionalTest):
         for sample_item in data.json:
             result_time = timeutils.parse_isotime(sample_item['timestamp'])
             result_time = result_time.replace(tzinfo=None)
-            self.assertTrue(result_time >= date_time)
+            self.assertGreaterEqual(result_time, date_time)
 
     def test_non_admin_tenant_sees_only_its_own_project(self):
         data = self.post_json(self.url,
@@ -286,7 +286,8 @@ class TestQueryMetersController(tests_api.FunctionalTest):
 
         self.assertEqual(2, len(data.json))
         for sample_item in data.json:
-            self.assertTrue(float(sample_item["metadata"]["util"]) >= 0.5)
+            self.assertGreaterEqual(float(sample_item["metadata"]["util"]),
+                                    0.5)
 
     def test_filter_with_negation(self):
         filter_expr = '{"not": {">=": {"metadata.util": 0.5}}}'
@@ -295,7 +296,7 @@ class TestQueryMetersController(tests_api.FunctionalTest):
 
         self.assertEqual(1, len(data.json))
         for sample_item in data.json:
-            self.assertTrue(float(sample_item["metadata"]["util"]) < 0.5)
+            self.assertLess(float(sample_item["metadata"]["util"]), 0.5)
 
     def test_limit_must_be_positive(self):
         data = self.post_json(self.url,

ceilometer/tests/functional/api/v2/test_list_resources_scenarios.py

@@ -35,9 +35,10 @@ class TestListResources(v2.FunctionalTest):
     def _verify_resource_timestamps(self, res, first, last):
         # Bounds need not be tight (see ceilometer bug #1288372)
         self.assertIn('first_sample_timestamp', res)
-        self.assertTrue(first.isoformat() >= res['first_sample_timestamp'])
+        self.assertGreaterEqual(first.isoformat(),
+                                res['first_sample_timestamp'])
         self.assertIn('last_sample_timestamp', res)
-        self.assertTrue(last.isoformat() <= res['last_sample_timestamp'])
+        self.assertLessEqual(last.isoformat(), res['last_sample_timestamp'])
 
     def test_instance_no_metadata(self):
         timestamp = datetime.datetime(2012, 7, 2, 10, 40)
@@ -508,12 +509,12 @@ class TestListResources(v2.FunctionalTest):
         links = data[0]['links']
         self.assertEqual(2, len(links))
         self.assertEqual('self', links[0]['rel'])
-        self.assertTrue((self.PATH_PREFIX + '/resources/resource-id')
-                        in links[0]['href'])
+        self.assertIn((self.PATH_PREFIX + '/resources/resource-id'),
+                      links[0]['href'])
         self.assertEqual('instance', links[1]['rel'])
-        self.assertTrue((self.PATH_PREFIX + '/meters/instance?'
-                         'q.field=resource_id&q.value=resource-id')
-                        in links[1]['href'])
+        self.assertIn((self.PATH_PREFIX + '/meters/instance?'
+                      'q.field=resource_id&q.value=resource-id'),
+                      links[1]['href'])
 
     def test_resource_skip_meter_links(self):
         sample1 = sample.Sample(
@@ -539,8 +540,8 @@ class TestListResources(v2.FunctionalTest):
         links = data[0]['links']
         self.assertEqual(len(links), 1)
         self.assertEqual(links[0]['rel'], 'self')
-        self.assertTrue((self.PATH_PREFIX + '/resources/resource-id')
-                        in links[0]['href'])
+        self.assertIn((self.PATH_PREFIX + '/resources/resource-id'),
+                      links[0]['href'])
 
 
 class TestListResourcesRestriction(v2.FunctionalTest):

ceilometer/tests/functional/storage/test_storage_scenarios.py

@@ -419,7 +419,7 @@ class RawSampleTest(DBTestBase):
         prev_timestamp = None
         for sample_item in self.conn.get_samples(f):
             if prev_timestamp is not None:
-                self.assertTrue(prev_timestamp >= sample_item.timestamp)
+                self.assertGreaterEqual(prev_timestamp, sample_item.timestamp)
             prev_timestamp = sample_item.timestamp
 
     def test_get_samples_by_user(self):
@@ -782,8 +782,8 @@ class ComplexSampleQueryTest(DBTestBase):
             self.assertIn(sample_item.resource_id,
                           set(["resource-id-42", "resource-id-44"]))
             self.assertEqual("cpu_util", sample_item.counter_name)
-            self.assertTrue(sample_item.counter_volume > 0.4)
-            self.assertTrue(sample_item.counter_volume <= 0.8)
+            self.assertGreater(sample_item.counter_volume, 0.4)
+            self.assertLessEqual(sample_item.counter_volume, 0.8)
 
     def test_query_complex_filter_with_limit(self):
         self._create_samples()
@@ -829,8 +829,8 @@ class ComplexSampleQueryTest(DBTestBase):
                                "resource-id-43",
                                "resource-id-44"]))
             self.assertEqual("cpu_util", sample_item.counter_name)
-            self.assertTrue(sample_item.counter_volume > 0.4)
-            self.assertTrue(sample_item.counter_volume <= 0.8)
+            self.assertGreater(sample_item.counter_volume, 0.4)
+            self.assertLessEqual(sample_item.counter_volume, 0.8)
 
     def test_query_complex_filter_with_list_with_limit(self):
         self._create_samples()
@@ -894,8 +894,8 @@ class ComplexSampleQueryTest(DBTestBase):
                                "resource-id-43",
                                "resource-id-44"]))
             self.assertEqual("cpu_util", sample_item.counter_name)
-            self.assertTrue(sample_item.counter_volume > 0.4)
-            self.assertTrue(sample_item.counter_volume <= 0.8)
+            self.assertGreater(sample_item.counter_volume, 0.4)
+            self.assertLessEqual(sample_item.counter_volume, 0.8)
 
     def test_query_simple_metadata_filter(self):
         self._create_samples()
@@ -936,7 +936,8 @@ class ComplexSampleQueryTest(DBTestBase):
                             "meta-value0.81" or
                              sample_item.resource_metadata["a_float_key"] <=
                              0.41))
-            self.assertTrue(sample_item.resource_metadata["an_int_key"] > 42)
+            self.assertGreater(sample_item.resource_metadata["an_int_key"],
+                               42)
 
     def test_query_mixed_data_and_metadata_filter(self):
         self._create_samples()
@@ -998,9 +999,10 @@ class ComplexSampleQueryTest(DBTestBase):
         self.assertEqual(3, len(results))
         for sample_item in results:
             self.assertEqual("resource-id-42", sample_item.resource_id)
-            self.assertTrue(sample_item.resource_metadata["an_int_key"] <= 43)
-            self.assertTrue(sample_item.resource_metadata["a_float_key"] >
-                            0.41)
+            self.assertLessEqual(sample_item.resource_metadata["an_int_key"],
+                                 43)
+            self.assertGreater(sample_item.resource_metadata["a_float_key"],
+                               0.41)
 
     def test_query_negated_complex_expression(self):
         self._create_samples()

ceilometer/tests/unit/event/test_converter.py

@@ -53,9 +53,8 @@ class ConverterBase(base.BaseTestCase):
 
     def assertHasTrait(self, event, name, value=None, dtype=None):
         traits = [trait for trait in event.traits if trait.name == name]
-        self.assertTrue(
-            len(traits) > 0,
-            "Trait %s not found in event %s" % (name, event))
+        self.assertGreater(len(traits), 0,
+                           "Trait %s not found in event %s" % (name, event))
         trait = traits[0]
         if value is not None:
             self.assertEqual(value, trait.value)