tests: Replace "self.assert_" by "self.assertTrue"

The assert_() method is deprecated and can be safely replaced by assertTrue().
This patch makes sure that running the tests does not fill the screen with
warnings.

Change-Id: I8966b7f7a44f1573a4d2c398717bfc68ae40b197

migrate/tests/changeset/test_changeset.py

@@ -74,7 +74,7 @@ def assert_numcols(num_of_expected_cols):
         create_column_func(col)
         assert_numcols(2)
         # data column exists
-        self.assert_(self.table.c.data.type.length, 40)
+        self.assertTrue(self.table.c.data.type.length, 40)
 
         col2 = self.table.c.data
         drop_column_func(col2)
@@ -109,11 +109,11 @@ def test_method_bound(self):
         ie. no table parameter passed to function
         """
         def add_func(col):
-            self.assert_(col.table is None, col.table)
+            self.assertTrue(col.table is None, col.table)
             self.table.append_column(col)
             return col.create()
         def drop_func(col):
-            #self.assert_(col.table is None,col.table)
+            #self.assertTrue(col.table is None,col.table)
             #self.table.append_column(col)
             return col.drop()
         return self.run_(add_func, drop_func)
@@ -642,14 +642,14 @@ def num_rows(col, content):
         self.refresh_table()
         alter_column(self.table.c.data2, name='atad')
         self.refresh_table(self.table.name)
-        self.assert_('data' not in self.table.c.keys())
-        self.assert_('atad' in self.table.c.keys())
+        self.assertTrue('data' not in self.table.c.keys())
+        self.assertTrue('atad' in self.table.c.keys())
         self.assertEqual(num_rows(self.table.c.atad, content), 1)
 
         # ...as a method, given a new name
         self.table.c.atad.alter(name='data')
         self.refresh_table(self.table.name)
-        self.assert_('atad' not in self.table.c.keys())
+        self.assertTrue('atad' not in self.table.c.keys())
         self.table.c.data # Should not raise exception
         self.assertEqual(num_rows(self.table.c.data, content), 1)
 
@@ -658,7 +658,7 @@ def num_rows(col, content):
                      name = 'atad', type=String(40),
                      server_default=self.table.c.data.server_default)
         self.refresh_table(self.table.name)
-        self.assert_('data' not in self.table.c.keys())
+        self.assertTrue('data' not in self.table.c.keys())
         self.table.c.atad   # Should not raise exception
         self.assertEqual(num_rows(self.table.c.atad, content), 1)
 
@@ -668,7 +668,7 @@ def num_rows(col, content):
             server_default=self.table.c.atad.server_default
             )
         self.refresh_table(self.table.name)
-        self.assert_('atad' not in self.table.c.keys())
+        self.assertTrue('atad' not in self.table.c.keys())
         self.table.c.data   # Should not raise exception
         self.assertEqual(num_rows(self.table.c.data,content), 1)
 
@@ -679,18 +679,18 @@ def test_type(self):
         # Just the new type
         self.table.c.data.alter(type=String(43))
         self.refresh_table(self.table.name)
-        self.assert_(isinstance(self.table.c.data.type, String))
+        self.assertTrue(isinstance(self.table.c.data.type, String))
         self.assertEqual(self.table.c.data.type.length, 43)
 
         # Different type
-        self.assert_(isinstance(self.table.c.id.type, Integer))
+        self.assertTrue(isinstance(self.table.c.id.type, Integer))
         self.assertEqual(self.table.c.id.nullable, False)
 
         if not self.engine.name == 'firebird':
             self.table.c.id.alter(type=String(20))
             self.assertEqual(self.table.c.id.nullable, False)
             self.refresh_table(self.table.name)
-            self.assert_(isinstance(self.table.c.id.type, String))
+            self.assertTrue(isinstance(self.table.c.id.type, String))
 
     @fixture.usedb()
     def test_default(self):
@@ -706,7 +706,7 @@ def test_default(self):
         self.refresh_table(self.table.name)
         #self.assertEqual(self.table.c.data.server_default.arg,default)
         # TextClause returned by autoload
-        self.assert_(default in str(self.table.c.data.server_default.arg))
+        self.assertTrue(default in str(self.table.c.data.server_default.arg))
         self.engine.execute(self.table.insert(), id=12)
         row = self._select_row()
         self.assertEqual(row['data'], default)
@@ -715,18 +715,18 @@ def test_default(self):
         default = 'your_default'
         self.table.c.data.alter(type=String(40), server_default=DefaultClause(default))
         self.refresh_table(self.table.name)
-        self.assert_(default in str(self.table.c.data.server_default.arg))
+        self.assertTrue(default in str(self.table.c.data.server_default.arg))
 
         # Drop/remove default
         self.table.c.data.alter(server_default=None)
         self.assertEqual(self.table.c.data.server_default, None)
 
         self.refresh_table(self.table.name)
         # server_default isn't necessarily None for Oracle
-        #self.assert_(self.table.c.data.server_default is None,self.table.c.data.server_default)
+        #self.assertTrue(self.table.c.data.server_default is None,self.table.c.data.server_default)
         self.engine.execute(self.table.insert(), id=11)
         row = self.table.select(self.table.c.id == 11).execution_options(autocommit=True).execute().fetchone()
-        self.assert_(row['data'] is None, row['data'])
+        self.assertTrue(row['data'] is None, row['data'])
 
     @fixture.usedb(not_supported='firebird')
     def test_null(self):
@@ -769,7 +769,7 @@ def test_alter_returns_delta(self):
         """Test if alter constructs return delta"""
 
         delta = self.table.c.data.alter(type=String(100))
-        self.assert_('type' in delta)
+        self.assertTrue('type' in delta)
 
     @fixture.usedb()
     def test_alter_all(self):
@@ -886,12 +886,12 @@ def test_deltas_two_columns(self):
 
         col = self.mkcol(server_default='foobar')
         self.verify(['type'], col, self.mkcol('id', Text, DefaultClause('foobar')), alter_metadata=True)
-        self.assert_(isinstance(col.type, Text))
+        self.assertTrue(isinstance(col.type, Text))
 
         col = self.mkcol()
         self.verify(['name', 'server_default', 'type'], col, self.mkcol('beep', Text, DefaultClause('foobar')),
                     alter_metadata=True)
-        self.assert_(isinstance(col.type, Text))
+        self.assertTrue(isinstance(col.type, Text))
         self.assertEqual(col.name, 'beep')
         self.assertEqual(col.server_default.arg, 'foobar')
 
@@ -908,7 +908,7 @@ def test_deltas_zero_columns(self):
         self.meta.clear()
         delta = self.verify(['type'], 'ids', table=self.table.name, type=String(80), metadata=self.meta,
                             alter_metadata=True)
-        self.assert_(self.table.name in self.meta)
+        self.assertTrue(self.table.name in self.meta)
         self.assertEqual(delta.result_column.type.length, 80)
         self.assertEqual(self.meta.tables.get(self.table.name).c.ids.type.length, 80)
 
@@ -942,7 +942,7 @@ def test_deltas_one_column(self):
 
         col_orig = self.mkcol(primary_key=True)
         self.verify(['name', 'type'], col_orig, name='id12', type=Text, alter_metadata=True)
-        self.assert_(isinstance(col_orig.type, Text))
+        self.assertTrue(isinstance(col_orig.type, Text))
         self.assertEqual(col_orig.name, 'id12')
 
         # test server default
@@ -956,7 +956,7 @@ def test_deltas_one_column(self):
         # no change
         col_orig = self.mkcol(server_default=DefaultClause('foobar'))
         delta = self.verify(['type'], col_orig, DefaultClause('foobar'), type=PickleType)
-        self.assert_(isinstance(delta.result_column.type, PickleType))
+        self.assertTrue(isinstance(delta.result_column.type, PickleType))
 
         # TODO: test server on update
         # TODO: test bind metadata

migrate/tests/changeset/test_constraint.py

@@ -41,7 +41,7 @@ def _create_table(self):
 
         # make sure we start at zero
         self.assertEqual(len(self.table.primary_key), 0)
-        self.assert_(isinstance(self.table.primary_key,
+        self.assertTrue(isinstance(self.table.primary_key,
             schema.PrimaryKeyConstraint), self.table.primary_key.__class__)
 
 
@@ -68,7 +68,7 @@ def _define_pk(self, *cols):
         pk.drop()
         self.refresh_table()
         self.assertEqual(len(self.table.primary_key), 0)
-        self.assert_(isinstance(self.table.primary_key, schema.PrimaryKeyConstraint))
+        self.assertTrue(isinstance(self.table.primary_key, schema.PrimaryKeyConstraint))
         return pk
 
     @fixture.usedb(not_supported='sqlite')
@@ -88,9 +88,9 @@ def test_define_fk(self):
                                   name="fk_id_fkey",
                                   ondelete="CASCADE")
         if SQLA_07:
-            self.assert_(list(self.table.c.fkey.foreign_keys) is not [])
+            self.assertTrue(list(self.table.c.fkey.foreign_keys) is not [])
         else:
-            self.assert_(self.table.c.fkey.foreign_keys._list is not [])
+            self.assertTrue(self.table.c.fkey.foreign_keys._list is not [])
         for key in fk.columns:
             self.assertEqual(key, self.table.c.fkey.name)
         self.assertEqual([e.column for e in fk.elements], [self.table.c.id])
@@ -112,9 +112,9 @@ def test_define_fk(self):
 
         self.refresh_table()
         if SQLA_07:
-            self.assert_(list(self.table.c.fkey.foreign_keys) is not [])
+            self.assertTrue(list(self.table.c.fkey.foreign_keys) is not [])
         else:
-            self.assert_(self.table.c.fkey.foreign_keys._list is not [])
+            self.assertTrue(self.table.c.fkey.foreign_keys._list is not [])
 
         fk.drop()
         self.refresh_table()

migrate/tests/versioning/test_api.py

@@ -15,7 +15,7 @@ def test_help(self):
         self.assertTrue(isinstance(api.help('help'), basestring))
         self.assertRaises(UsageError, api.help)
         self.assertRaises(UsageError, api.help, 'foobar')
-        self.assert_(isinstance(api.help('create'), str))
+        self.assertTrue(isinstance(api.help('create'), str))
 
         # test that all commands return some text
         for cmd in api.__all__:

migrate/tests/versioning/test_cfgparse.py

@@ -12,7 +12,7 @@ class TestConfigParser(fixture.Base):
     def test_to_dict(self):
         """Correctly interpret config results as dictionaries"""
         parser = cfgparse.Parser(dict(default_value=42))
-        self.assert_(len(parser.sections()) == 0)
+        self.assertTrue(len(parser.sections()) == 0)
         parser.add_section('section')
         parser.set('section','option','value')
         self.assertEqual(parser.get('section', 'option'), 'value')

migrate/tests/versioning/test_keyedinstance.py

@@ -24,22 +24,22 @@ def __init__(self,value):
 
         # Different key: different instance
         b10 = Uniq1('b')
-        self.assert_(a10 is not b10)
+        self.assertTrue(a10 is not b10)
 
         # Different class: different instance
         a20 = Uniq2('a')
-        self.assert_(a10 is not a20)
+        self.assertTrue(a10 is not a20)
 
         # Same key/class: same instance
         a11 = Uniq1('a')
-        self.assert_(a10 is a11)
+        self.assertTrue(a10 is a11)
 
         # __init__ is called
         self.assertEqual(a10.value,'a')
 
         # clear() causes us to forget all existing instances
         Uniq1.clear()
         a12 = Uniq1('a')
-        self.assert_(a10 is not a12)
+        self.assertTrue(a10 is not a12)
 
         self.assertRaises(NotImplementedError, KeyedInstance._key)

migrate/tests/versioning/test_pathed.py

@@ -9,9 +9,9 @@ def test_parent_path(self):
         sdirpath='/fgsfds/moot/'
 
         result='/fgsfds'
-        self.assert_(result==Pathed._parent_path(filepath))
-        self.assert_(result==Pathed._parent_path(dirpath))
-        self.assert_(result==Pathed._parent_path(sdirpath))
+        self.assertTrue(result==Pathed._parent_path(filepath))
+        self.assertTrue(result==Pathed._parent_path(dirpath))
+        self.assertTrue(result==Pathed._parent_path(sdirpath))
 
     def test_new(self):
         """Pathed(path) shouldn't create duplicate objects of the same path"""
@@ -20,13 +20,13 @@ class Test(Pathed):
             attr=None
         o1=Test(path)
         o2=Test(path)
-        self.assert_(isinstance(o1,Test))
-        self.assert_(o1.path==path)
-        self.assert_(o1 is o2)
+        self.assertTrue(isinstance(o1,Test))
+        self.assertTrue(o1.path==path)
+        self.assertTrue(o1 is o2)
         o1.attr='herring'
-        self.assert_(o2.attr=='herring')
+        self.assertTrue(o2.attr=='herring')
         o2.attr='shrubbery'
-        self.assert_(o1.attr=='shrubbery')
+        self.assertTrue(o1.attr=='shrubbery')
 
     def test_parent(self):
         """Parents should be fetched correctly"""
@@ -45,7 +45,7 @@ class Child(Pathed):
         path='/fgsfds/moot.py'
         parent_path='/fgsfds'
         object=Child(path)
-        self.assert_(isinstance(object,Child))
-        self.assert_(isinstance(object.parent,Parent))
-        self.assert_(object.path==path)
-        self.assert_(object.parent.path==parent_path)
+        self.assertTrue(isinstance(object,Child))
+        self.assertTrue(isinstance(object.parent,Parent))
+        self.assertTrue(object.path==path)
+        self.assertTrue(object.parent.path==parent_path)