From 07909159ae22dc0d399b9618dcf0f79a1d0332bf Mon Sep 17 00:00:00 2001 From: Cyril Roelandt Date: Wed, 19 Mar 2014 17:29:49 +0100 Subject: 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 | 42 +++++++++++----------- migrate/tests/changeset/test_constraint.py | 12 +++---- migrate/tests/versioning/test_api.py | 2 +- migrate/tests/versioning/test_cfgparse.py | 2 +- migrate/tests/versioning/test_keyedinstance.py | 8 ++--- migrate/tests/versioning/test_pathed.py | 24 ++++++------- migrate/tests/versioning/test_repository.py | 50 +++++++++++++------------- migrate/tests/versioning/test_schema.py | 2 +- migrate/tests/versioning/test_script.py | 2 +- migrate/tests/versioning/test_shell.py | 36 +++++++++---------- migrate/tests/versioning/test_template.py | 6 ++-- migrate/tests/versioning/test_util.py | 8 ++--- migrate/tests/versioning/test_version.py | 22 ++++++------ 13 files changed, 108 insertions(+), 108 deletions(-) diff --git a/migrate/tests/changeset/test_changeset.py b/migrate/tests/changeset/test_changeset.py index 1ea7219..dcbd473 100644 --- a/migrate/tests/changeset/test_changeset.py +++ b/migrate/tests/changeset/test_changeset.py @@ -74,7 +74,7 @@ class TestAddDropColumn(fixture.DB): 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 @@ class TestAddDropColumn(fixture.DB): 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 @@ class TestColumnChange(fixture.DB): 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 @@ class TestColumnChange(fixture.DB): 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 @@ class TestColumnChange(fixture.DB): 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 @@ class TestColumnChange(fixture.DB): # 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 @@ class TestColumnChange(fixture.DB): 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,7 +715,7 @@ class TestColumnChange(fixture.DB): 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) @@ -723,10 +723,10 @@ class TestColumnChange(fixture.DB): 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 @@ class TestColumnChange(fixture.DB): """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 @@ class TestColumnDelta(fixture.DB): 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 @@ class TestColumnDelta(fixture.DB): 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 @@ class TestColumnDelta(fixture.DB): 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 @@ class TestColumnDelta(fixture.DB): # 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 diff --git a/migrate/tests/changeset/test_constraint.py b/migrate/tests/changeset/test_constraint.py index 941030a..d27554e 100644 --- a/migrate/tests/changeset/test_constraint.py +++ b/migrate/tests/changeset/test_constraint.py @@ -41,7 +41,7 @@ class CommonTestConstraint(fixture.DB): # 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 @@ class TestConstraint(CommonTestConstraint): 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 @@ class TestConstraint(CommonTestConstraint): 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 @@ class TestConstraint(CommonTestConstraint): 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() diff --git a/migrate/tests/versioning/test_api.py b/migrate/tests/versioning/test_api.py index 855c49c..4a93c5c 100644 --- a/migrate/tests/versioning/test_api.py +++ b/migrate/tests/versioning/test_api.py @@ -15,7 +15,7 @@ class TestAPI(Pathed): 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__: diff --git a/migrate/tests/versioning/test_cfgparse.py b/migrate/tests/versioning/test_cfgparse.py index 1d0d7e8..39649cc 100644 --- a/migrate/tests/versioning/test_cfgparse.py +++ b/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') diff --git a/migrate/tests/versioning/test_keyedinstance.py b/migrate/tests/versioning/test_keyedinstance.py index d5e6ba2..485cbbb 100644 --- a/migrate/tests/versioning/test_keyedinstance.py +++ b/migrate/tests/versioning/test_keyedinstance.py @@ -24,15 +24,15 @@ class TestKeydInstance(fixture.Base): # 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') @@ -40,6 +40,6 @@ class TestKeydInstance(fixture.Base): # 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) diff --git a/migrate/tests/versioning/test_pathed.py b/migrate/tests/versioning/test_pathed.py index 2798067..53f0b47 100644 --- a/migrate/tests/versioning/test_pathed.py +++ b/migrate/tests/versioning/test_pathed.py @@ -9,9 +9,9 @@ class TestPathed(fixture.Base): 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 TestPathed(fixture.Base): 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 TestPathed(fixture.Base): 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) diff --git a/migrate/tests/versioning/test_repository.py b/migrate/tests/versioning/test_repository.py index 37bb5e7..0949b69 100644 --- a/migrate/tests/versioning/test_repository.py +++ b/migrate/tests/versioning/test_repository.py @@ -22,12 +22,12 @@ class TestRepository(fixture.Pathed): repo = Repository.create(path, name) config_path = repo.config.path manage_path = os.path.join(repo.path, 'manage.py') - self.assert_(repo) + self.assertTrue(repo) # Files should actually be created - self.assert_(os.path.exists(path)) - self.assert_(os.path.exists(config_path)) - self.assert_(os.path.exists(manage_path)) + self.assertTrue(os.path.exists(path)) + self.assertTrue(os.path.exists(config_path)) + self.assertTrue(os.path.exists(manage_path)) # Can't create it again: it already exists self.assertRaises(exceptions.PathFoundError, Repository.create, path, name) @@ -39,9 +39,9 @@ class TestRepository(fixture.Pathed): path = self.test_create() repos = Repository(path) - self.assert_(repos) - self.assert_(repos.config) - self.assert_(repos.config.get('db_settings', 'version_table')) + self.assertTrue(repos) + self.assertTrue(repos.config) + self.assertTrue(repos.config.get('db_settings', 'version_table')) # version_table's default isn't none self.assertNotEquals(repos.config.get('db_settings', 'version_table'), 'None') @@ -49,7 +49,7 @@ class TestRepository(fixture.Pathed): def test_load_notfound(self): """Nonexistant repositories shouldn't be loaded""" path = self.tmp_repos() - self.assert_(not os.path.exists(path)) + self.assertTrue(not os.path.exists(path)) self.assertRaises(exceptions.InvalidRepositoryError, Repository, path) def test_load_invalid(self): @@ -78,23 +78,23 @@ class TestVersionedRepository(fixture.Pathed): self.assertEqual(repos.latest, 0) # repos.latest isn't an integer, but a VerNum # (so we can't just assume the following tests are correct) - self.assert_(repos.latest >= 0) - self.assert_(repos.latest < 1) + self.assertTrue(repos.latest >= 0) + self.assertTrue(repos.latest < 1) # Create a script and test again repos.create_script('') self.assertEqual(repos.latest, 1) - self.assert_(repos.latest >= 0) - self.assert_(repos.latest >= 1) - self.assert_(repos.latest < 2) + self.assertTrue(repos.latest >= 0) + self.assertTrue(repos.latest >= 1) + self.assertTrue(repos.latest < 2) # Create a new script and test again repos.create_script('') self.assertEqual(repos.latest, 2) - self.assert_(repos.latest >= 0) - self.assert_(repos.latest >= 1) - self.assert_(repos.latest >= 2) - self.assert_(repos.latest < 3) + self.assertTrue(repos.latest >= 0) + self.assertTrue(repos.latest >= 1) + self.assertTrue(repos.latest >= 2) + self.assertTrue(repos.latest < 3) def test_timestmap_numbering_version(self): @@ -105,8 +105,8 @@ class TestVersionedRepository(fixture.Pathed): self.assertEqual(repos.latest, 0) # repos.latest isn't an integer, but a VerNum # (so we can't just assume the following tests are correct) - self.assert_(repos.latest >= 0) - self.assert_(repos.latest < 1) + self.assertTrue(repos.latest >= 0) + self.assertTrue(repos.latest < 1) # Create a script and test again now = int(datetime.utcnow().strftime('%Y%m%d%H%M%S')) @@ -134,8 +134,8 @@ class TestVersionedRepository(fixture.Pathed): """Repository.version() (no params) returns the latest version""" repos = Repository(self.path_repos) repos.create_script('') - self.assert_(repos.version(repos.latest) is repos.version()) - self.assert_(repos.version() is not None) + self.assertTrue(repos.version(repos.latest) is repos.version()) + self.assertTrue(repos.version() is not None) def test_changeset(self): """Repositories can create changesets properly""" @@ -152,9 +152,9 @@ class TestVersionedRepository(fixture.Pathed): uniq = list() # Changesets are iterable for version, change in changeset: - self.assert_(isinstance(change, BaseScript)) + self.assertTrue(isinstance(change, BaseScript)) # Changes aren't identical - self.assert_(id(change) not in uniq) + self.assertTrue(id(change) not in uniq) uniq.append(id(change)) return changeset @@ -209,8 +209,8 @@ class TestVersionedRepository(fixture.Pathed): repos.create_script('') # since we normally create 3 digit ones, let's see if we blow up - self.assert_(os.path.exists('%s/versions/1000.py' % self.path_repos)) - self.assert_(os.path.exists('%s/versions/1001.py' % self.path_repos)) + self.assertTrue(os.path.exists('%s/versions/1000.py' % self.path_repos)) + self.assertTrue(os.path.exists('%s/versions/1001.py' % self.path_repos)) # TODO: test manage file diff --git a/migrate/tests/versioning/test_schema.py b/migrate/tests/versioning/test_schema.py index 0089c38..d92eed3 100644 --- a/migrate/tests/versioning/test_schema.py +++ b/migrate/tests/versioning/test_schema.py @@ -117,7 +117,7 @@ class TestControlledSchema(fixture.Pathed, fixture.DB): # Can't have custom errors with assertRaises... try: ControlledSchema.create(self.engine, self.repos, version) - self.assert_(False, repr(version)) + self.assertTrue(False, repr(version)) except exceptions.InvalidVersionError: pass diff --git a/migrate/tests/versioning/test_script.py b/migrate/tests/versioning/test_script.py index 95ee58c..d30647b 100644 --- a/migrate/tests/versioning/test_script.py +++ b/migrate/tests/versioning/test_script.py @@ -34,7 +34,7 @@ class TestPyScript(fixture.Pathed, fixture.DB): path = self.tmp_py() # Creating a file that doesn't exist should succeed self.cls.create(path) - self.assert_(os.path.exists(path)) + self.assertTrue(os.path.exists(path)) # Created file should be a valid script (If not, raises an error) self.cls.verify(path) # Can't create it again: it already exists diff --git a/migrate/tests/versioning/test_shell.py b/migrate/tests/versioning/test_shell.py index 4ba6bce..743828d 100644 --- a/migrate/tests/versioning/test_shell.py +++ b/migrate/tests/versioning/test_shell.py @@ -96,7 +96,7 @@ class TestShellCommands(Shell): result = self.env.run('migrate create %s repository_name' % repos) # Files should actually be created - self.assert_(os.path.exists(repos)) + self.assertTrue(os.path.exists(repos)) # The default table should not be None repos_ = Repository(repos) @@ -113,13 +113,13 @@ class TestShellCommands(Shell): result = self.env.run('migrate create %s repository_name' % repos) result = self.env.run('migrate script --repository=%s Desc' % repos) - self.assert_(os.path.exists('%s/versions/001_Desc.py' % repos)) + self.assertTrue(os.path.exists('%s/versions/001_Desc.py' % repos)) result = self.env.run('migrate script More %s' % repos) - self.assert_(os.path.exists('%s/versions/002_More.py' % repos)) + self.assertTrue(os.path.exists('%s/versions/002_More.py' % repos)) result = self.env.run('migrate script "Some Random name" %s' % repos) - self.assert_(os.path.exists('%s/versions/003_Some_Random_name.py' % repos)) + self.assertTrue(os.path.exists('%s/versions/003_Some_Random_name.py' % repos)) def test_script_sql(self): """We can create a migration sql script via the command line""" @@ -127,24 +127,24 @@ class TestShellCommands(Shell): result = self.env.run('migrate create %s repository_name' % repos) result = self.env.run('migrate script_sql mydb foo %s' % repos) - self.assert_(os.path.exists('%s/versions/001_foo_mydb_upgrade.sql' % repos)) - self.assert_(os.path.exists('%s/versions/001_foo_mydb_downgrade.sql' % repos)) + self.assertTrue(os.path.exists('%s/versions/001_foo_mydb_upgrade.sql' % repos)) + self.assertTrue(os.path.exists('%s/versions/001_foo_mydb_downgrade.sql' % repos)) # Test creating a second result = self.env.run('migrate script_sql postgres foo --repository=%s' % repos) - self.assert_(os.path.exists('%s/versions/002_foo_postgres_upgrade.sql' % repos)) - self.assert_(os.path.exists('%s/versions/002_foo_postgres_downgrade.sql' % repos)) + self.assertTrue(os.path.exists('%s/versions/002_foo_postgres_upgrade.sql' % repos)) + self.assertTrue(os.path.exists('%s/versions/002_foo_postgres_downgrade.sql' % repos)) # TODO: test --previews def test_manage(self): """Create a project management script""" script = self.tmp_py() - self.assert_(not os.path.exists(script)) + self.assertTrue(not os.path.exists(script)) # No attempt is made to verify correctness of the repository path here result = self.env.run('migrate manage %s --repository=/bla/' % script) - self.assert_(os.path.exists(script)) + self.assertTrue(os.path.exists(script)) class TestShellRepository(Shell): @@ -177,7 +177,7 @@ class TestShellRepository(Shell): filename = '%s/versions/001_Desc.py' % self.path_repos source = open(filename).read() - self.assert_(source.find('def upgrade') >= 0) + self.assertTrue(source.find('def upgrade') >= 0) # Version is now 1 result = self.env.run('migrate version %s' % self.path_repos) @@ -190,10 +190,10 @@ class TestShellRepository(Shell): # We can also send the source to a file... test that too result = self.env.run('migrate source 1 %s --repository=%s' % (filename, self.path_repos)) - self.assert_(os.path.exists(filename)) + self.assertTrue(os.path.exists(filename)) fd = open(filename) result = fd.read() - self.assert_(result.strip() == source.strip()) + self.assertTrue(result.strip() == source.strip()) class TestShellDatabase(Shell, DB): @@ -473,19 +473,19 @@ class TestShellDatabase(Shell, DB): # Setup helper script. result = self.env.run('migrate manage %s --repository=%s --url=%s --model=%s'\ % (script_path, repos_path, self.url, model_module)) - self.assert_(os.path.exists(script_path)) + self.assertTrue(os.path.exists(script_path)) # Model is defined but database is empty. result = self.env.run('migrate compare_model_to_db %s %s --model=%s' \ % (self.url, repos_path, model_module)) - self.assert_("tables missing from database: tmp_account_rundiffs" in result.stdout) + self.assertTrue("tables missing from database: tmp_account_rundiffs" in result.stdout) # Test Deprecation result = self.env.run('migrate compare_model_to_db %s %s --model=%s' \ % (self.url, repos_path, model_module.replace(":", ".")), expect_error=True) self.assertEqual(result.returncode, 0) self.assertTrue("DeprecationWarning" in result.stderr) - self.assert_("tables missing from database: tmp_account_rundiffs" in result.stdout) + self.assertTrue("tables missing from database: tmp_account_rundiffs" in result.stdout) # Update db to latest model. result = self.env.run('migrate update_db_from_model %s %s %s'\ @@ -495,7 +495,7 @@ class TestShellDatabase(Shell, DB): result = self.env.run('migrate compare_model_to_db %s %s %s'\ % (self.url, repos_path, model_module)) - self.assert_("No schema diffs" in result.stdout) + self.assertTrue("No schema diffs" in result.stdout) result = self.env.run('migrate drop_version_control %s %s' % (self.url, repos_path), expect_error=True) result = self.env.run('migrate version_control %s %s' % (self.url, repos_path)) @@ -550,6 +550,6 @@ class TestShellDatabase(Shell, DB): #result = self.env.run('migrate compare_model_to_db %s %s %s'\ #% (self.url, repos_path, model_module)) - #self.assert_("No schema diffs" in result.stdout) + #self.assertTrue("No schema diffs" in result.stdout) self.meta.drop_all() # in case junk tables are lying around in the test database diff --git a/migrate/tests/versioning/test_template.py b/migrate/tests/versioning/test_template.py index 16bdc36..a079d8b 100644 --- a/migrate/tests/versioning/test_template.py +++ b/migrate/tests/versioning/test_template.py @@ -15,17 +15,17 @@ class TestTemplate(fixture.Pathed): def test_templates(self): """We can find the path to all repository templates""" path = str(Template()) - self.assert_(os.path.exists(path)) + self.assertTrue(os.path.exists(path)) def test_repository(self): """We can find the path to the default repository""" path = Template().get_repository() - self.assert_(os.path.exists(path)) + self.assertTrue(os.path.exists(path)) def test_script(self): """We can find the path to the default migration script""" path = Template().get_script() - self.assert_(os.path.exists(path)) + self.assertTrue(os.path.exists(path)) def test_custom_templates_and_themes(self): """Users can define their own templates with themes""" diff --git a/migrate/tests/versioning/test_util.py b/migrate/tests/versioning/test_util.py index db4ea26..280784a 100644 --- a/migrate/tests/versioning/test_util.py +++ b/migrate/tests/versioning/test_util.py @@ -20,7 +20,7 @@ class TestUtil(fixture.Pathed): url = 'sqlite://' engine = construct_engine(url) - self.assert_(engine.name == 'sqlite') + self.assertTrue(engine.name == 'sqlite') # keyword arg engine = construct_engine(url, engine_arg_encoding='utf-8') @@ -108,7 +108,7 @@ class TestUtil(fixture.Pathed): # deprecated spelling FakeFloat = load_model('test_load_model.FakeFloat') - self.assert_(isinstance(FakeFloat(), int)) + self.assertTrue(isinstance(FakeFloat(), int)) self.assertEqual(len(w),1) self.assertTrue(issubclass(w[-1].category, @@ -122,10 +122,10 @@ class TestUtil(fixture.Pathed): cw.__exit__() FakeFloat = load_model('test_load_model:FakeFloat') - self.assert_(isinstance(FakeFloat(), int)) + self.assertTrue(isinstance(FakeFloat(), int)) FakeFloat = load_model(FakeFloat) - self.assert_(isinstance(FakeFloat(), int)) + self.assertTrue(isinstance(FakeFloat(), int)) def test_guess_obj_type(self): """guess object type from string""" diff --git a/migrate/tests/versioning/test_version.py b/migrate/tests/versioning/test_version.py index 25ab2b1..00ce695 100644 --- a/migrate/tests/versioning/test_version.py +++ b/migrate/tests/versioning/test_version.py @@ -23,7 +23,7 @@ class TestVerNum(fixture.Base): """Two version with the same number should be equal""" a = VerNum(1) b = VerNum(1) - self.assert_(a is b) + self.assertTrue(a is b) self.assertEqual(VerNum(VerNum(2)), VerNum(2)) @@ -31,11 +31,11 @@ class TestVerNum(fixture.Base): self.assertEqual(VerNum(1) + VerNum(1), VerNum(2)) self.assertEqual(VerNum(1) + 1, 2) self.assertEqual(VerNum(1) + 1, '2') - self.assert_(isinstance(VerNum(1) + 1, VerNum)) + self.assertTrue(isinstance(VerNum(1) + 1, VerNum)) def test_sub(self): self.assertEqual(VerNum(1) - 1, 0) - self.assert_(isinstance(VerNum(1) - 1, VerNum)) + self.assertTrue(isinstance(VerNum(1) - 1, VerNum)) self.assertRaises(ValueError, lambda: VerNum(0) - 1) def test_eq(self): @@ -46,27 +46,27 @@ class TestVerNum(fixture.Base): self.assertNotEqual(VerNum(1), 2) def test_ne(self): - self.assert_(VerNum(1) != 2) + self.assertTrue(VerNum(1) != 2) self.assertFalse(VerNum(1) != 1) def test_lt(self): self.assertFalse(VerNum(1) < 1) - self.assert_(VerNum(1) < 2) + self.assertTrue(VerNum(1) < 2) self.assertFalse(VerNum(2) < 1) def test_le(self): - self.assert_(VerNum(1) <= 1) - self.assert_(VerNum(1) <= 2) + self.assertTrue(VerNum(1) <= 1) + self.assertTrue(VerNum(1) <= 2) self.assertFalse(VerNum(2) <= 1) def test_gt(self): self.assertFalse(VerNum(1) > 1) self.assertFalse(VerNum(1) > 2) - self.assert_(VerNum(2) > 1) + self.assertTrue(VerNum(2) > 1) def test_ge(self): - self.assert_(VerNum(1) >= 1) - self.assert_(VerNum(2) >= 1) + self.assertTrue(VerNum(1) >= 1) + self.assertTrue(VerNum(2) >= 1) self.assertFalse(VerNum(1) >= 2) @@ -114,7 +114,7 @@ class TestVersion(fixture.Pathed): coll.create_new_python_version("'") ver = coll.version() - self.assert_(ver.script().source()) + self.assertTrue(ver.script().source()) def test_create_new_sql_version(self): coll = Collection(self.temp_usable_dir) -- cgit v1.2.1