openstack/deb-python-cassandra-driver
Code Issues Proposed changes

assertEquals --> assertEqual

Browse Source 
the former is deprecated
This commit is contained in:
Adam Holmberg
2016-07-28 12:04:58 -05:00
parent c5c70e11c9
commit 0f18ded6fc
4 changed files with 91 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
tests/integration/cqlengine/model/test_class_construction.py
View File

@@ -63,13 +63,13 @@ class TestModelClassFunction(BaseCassEngTestCase):
inst1 = TestPerson()
self.assertHasAttr(inst1, 'first_name')
self.assertHasAttr(inst1, 'last_name')
self.assertEquals(inst1.first_name, 'kevin')
self.assertEquals(inst1.last_name, 'deldycke')
self.assertEqual(inst1.first_name, 'kevin')
self.assertEqual(inst1.last_name, 'deldycke')
# Check that values on instantiation overrides defaults.
inst2 = TestPerson(first_name='bob', last_name='joe')
self.assertEquals(inst2.first_name, 'bob')
self.assertEquals(inst2.last_name, 'joe')
self.assertEqual(inst2.first_name, 'bob')
self.assertEqual(inst2.last_name, 'joe')
def test_db_map(self):
"""

16
tests/integration/cqlengine/model/test_model_io.py
View File

@@ -89,13 +89,13 @@ class TestModelIO(BaseCassEngTestCase):
tm = TestModel(count=8, text='123456789')
# Tests that values are available on instantiation.
self.assertIsNotNone(tm['id'])
self.assertEquals(tm.count, 8)
self.assertEquals(tm.text, '123456789')
self.assertEqual(tm.count, 8)
self.assertEqual(tm.text, '123456789')
tm.save()
tm2 = TestModel.objects(id=tm.id).first()
for cname in tm._columns.keys():
self.assertEquals(getattr(tm, cname), getattr(tm2, cname))
self.assertEqual(getattr(tm, cname), getattr(tm2, cname))
def test_model_read_as_dict(self):
"""
@@ -499,15 +499,15 @@ class TestUpdating(BaseCassEngTestCase):
int3=7777,
int5=5555)
self.assertEquals(instance.id, 1)
self.assertEquals(instance.int1, 9999)
self.assertEquals(instance.int2, 456)
self.assertEquals(instance.int3, 7777)
self.assertEqual(instance.id, 1)
self.assertEqual(instance.int1, 9999)
self.assertEqual(instance.int2, 456)
self.assertEqual(instance.int3, 7777)
self.assertIsNotNone(instance.int4)
self.assertIsInstance(instance.int4, int)
self.assertGreaterEqual(instance.int4, 0)
self.assertLessEqual(instance.int4, 1000)
self.assertEquals(instance.int5, 5555)
self.assertEqual(instance.int5, 5555)
self.assertTrue(instance.int6 is None)
# All previous values are unset as the object hasn't been persisted

62
tests/integration/standard/test_metadata.py
View File

@@ -2226,37 +2226,37 @@ class MaterializedViewMetadataTestComplex(BasicSegregatedKeyspaceUnitTestCase):
self.assertIsNotNone(score_table.columns['score'])
# Validate basic mv information
self.assertEquals(mv.keyspace_name, self.keyspace_name)
self.assertEquals(mv.name, "monthlyhigh")
self.assertEquals(mv.base_table_name, "scores")
self.assertEqual(mv.keyspace_name, self.keyspace_name)
self.assertEqual(mv.name, "monthlyhigh")
self.assertEqual(mv.base_table_name, "scores")
self.assertFalse(mv.include_all_columns)
# Validate that all columns are preset and correct
mv_columns = list(mv.columns.values())
self.assertEquals(len(mv_columns), 6)
self.assertEqual(len(mv_columns), 6)
game_column = mv_columns[0]
self.assertIsNotNone(game_column)
self.assertEquals(game_column.name, 'game')
self.assertEquals(game_column, mv.partition_key[0])
self.assertEqual(game_column.name, 'game')
self.assertEqual(game_column, mv.partition_key[0])
year_column = mv_columns[1]
self.assertIsNotNone(year_column)
self.assertEquals(year_column.name, 'year')
self.assertEquals(year_column, mv.partition_key[1])
self.assertEqual(year_column.name, 'year')
self.assertEqual(year_column, mv.partition_key[1])
month_column = mv_columns[2]
self.assertIsNotNone(month_column)
self.assertEquals(month_column.name, 'month')
self.assertEquals(month_column, mv.partition_key[2])
self.assertEqual(month_column.name, 'month')
self.assertEqual(month_column, mv.partition_key[2])
def compare_columns(a, b, name):
self.assertEquals(a.name, name)
self.assertEquals(a.name, b.name)
self.assertEquals(a.table, b.table)
self.assertEquals(a.cql_type, b.cql_type)
self.assertEquals(a.is_static, b.is_static)
self.assertEquals(a.is_reversed, b.is_reversed)
self.assertEqual(a.name, name)
self.assertEqual(a.name, b.name)
self.assertEqual(a.table, b.table)
self.assertEqual(a.cql_type, b.cql_type)
self.assertEqual(a.is_static, b.is_static)
self.assertEqual(a.is_reversed, b.is_reversed)
score_column = mv_columns[3]
compare_columns(score_column, mv.clustering_key[0], 'score')
@@ -2333,7 +2333,7 @@ class MaterializedViewMetadataTestComplex(BasicSegregatedKeyspaceUnitTestCase):
self.assertIn("fouls", mv_alltime.columns)
mv_alltime_fouls_comumn = self.cluster.metadata.keyspaces[self.keyspace_name].views["alltimehigh"].columns['fouls']
self.assertEquals(mv_alltime_fouls_comumn.cql_type, 'int')
self.assertEqual(mv_alltime_fouls_comumn.cql_type, 'int')
def test_base_table_type_alter_mv(self):
"""
@@ -2374,7 +2374,7 @@ class MaterializedViewMetadataTestComplex(BasicSegregatedKeyspaceUnitTestCase):
self.assertEqual(len(self.cluster.metadata.keyspaces[self.keyspace_name].views), 1)
score_column = self.cluster.metadata.keyspaces[self.keyspace_name].tables['scores'].columns['score']
self.assertEquals(score_column.cql_type, 'blob')
self.assertEqual(score_column.cql_type, 'blob')
# until CASSANDRA-9920+CASSANDRA-10500 MV updates are only available later with an async event
for i in range(10):
@@ -2383,7 +2383,7 @@ class MaterializedViewMetadataTestComplex(BasicSegregatedKeyspaceUnitTestCase):
break
time.sleep(.2)
self.assertEquals(score_mv_column.cql_type, 'blob')
self.assertEqual(score_mv_column.cql_type, 'blob')
def test_metadata_with_quoted_identifiers(self):
"""
@@ -2436,31 +2436,31 @@ class MaterializedViewMetadataTestComplex(BasicSegregatedKeyspaceUnitTestCase):
self.assertIsNotNone(t1_table.columns['the Value'])
# Validate basic mv information
self.assertEquals(mv.keyspace_name, self.keyspace_name)
self.assertEquals(mv.name, "mv1")
self.assertEquals(mv.base_table_name, "t1")
self.assertEqual(mv.keyspace_name, self.keyspace_name)
self.assertEqual(mv.name, "mv1")
self.assertEqual(mv.base_table_name, "t1")
self.assertFalse(mv.include_all_columns)
# Validate that all columns are preset and correct
mv_columns = list(mv.columns.values())
self.assertEquals(len(mv_columns), 3)
self.assertEqual(len(mv_columns), 3)
theKey_column = mv_columns[0]
self.assertIsNotNone(theKey_column)
self.assertEquals(theKey_column.name, 'theKey')
self.assertEquals(theKey_column, mv.partition_key[0])
self.assertEqual(theKey_column.name, 'theKey')
self.assertEqual(theKey_column, mv.partition_key[0])
cluster_column = mv_columns[1]
self.assertIsNotNone(cluster_column)
self.assertEquals(cluster_column.name, 'the;Clustering')
self.assertEquals(cluster_column.name, mv.clustering_key[0].name)
self.assertEquals(cluster_column.table, mv.clustering_key[0].table)
self.assertEquals(cluster_column.is_static, mv.clustering_key[0].is_static)
self.assertEquals(cluster_column.is_reversed, mv.clustering_key[0].is_reversed)
self.assertEqual(cluster_column.name, 'the;Clustering')
self.assertEqual(cluster_column.name, mv.clustering_key[0].name)
self.assertEqual(cluster_column.table, mv.clustering_key[0].table)
self.assertEqual(cluster_column.is_static, mv.clustering_key[0].is_static)
self.assertEqual(cluster_column.is_reversed, mv.clustering_key[0].is_reversed)
value_column = mv_columns[2]
self.assertIsNotNone(value_column)
self.assertEquals(value_column.name, 'the Value')
self.assertEqual(value_column.name, 'the Value')
@dseonly

96
tests/integration/standard/test_query.py
View File

@@ -914,73 +914,73 @@ class MaterializedViewQueryTest(BasicSharedKeyspaceUnitTestCase):
query_statement = SimpleStatement("SELECT * FROM {0}.alltimehigh WHERE game='Coup'".format(self.keyspace_name),
consistency_level=ConsistencyLevel.QUORUM)
results = self.session.execute(query_statement)
self.assertEquals(results[0].game, 'Coup')
self.assertEquals(results[0].year, 2015)
self.assertEquals(results[0].month, 5)
self.assertEquals(results[0].day, 1)
self.assertEquals(results[0].score, 4000)
self.assertEquals(results[0].user, "pcmanus")
self.assertEqual(results[0].game, 'Coup')
self.assertEqual(results[0].year, 2015)
self.assertEqual(results[0].month, 5)
self.assertEqual(results[0].day, 1)
self.assertEqual(results[0].score, 4000)
self.assertEqual(results[0].user, "pcmanus")
# Test prepared statement and daily high filtering
prepared_query = self.session.prepare("SELECT * FROM {0}.dailyhigh WHERE game=? AND year=? AND month=? and day=?".format(self.keyspace_name))
bound_query = prepared_query.bind(("Coup", 2015, 6, 2))
results = self.session.execute(bound_query)
self.assertEquals(results[0].game, 'Coup')
self.assertEquals(results[0].year, 2015)
self.assertEquals(results[0].month, 6)
self.assertEquals(results[0].day, 2)
self.assertEquals(results[0].score, 2000)
self.assertEquals(results[0].user, "pcmanus")
self.assertEqual(results[0].game, 'Coup')
self.assertEqual(results[0].year, 2015)
self.assertEqual(results[0].month, 6)
self.assertEqual(results[0].day, 2)
self.assertEqual(results[0].score, 2000)
self.assertEqual(results[0].user, "pcmanus")
self.assertEquals(results[1].game, 'Coup')
self.assertEquals(results[1].year, 2015)
self.assertEquals(results[1].month, 6)
self.assertEquals(results[1].day, 2)
self.assertEquals(results[1].score, 1000)
self.assertEquals(results[1].user, "tjake")
self.assertEqual(results[1].game, 'Coup')
self.assertEqual(results[1].year, 2015)
self.assertEqual(results[1].month, 6)
self.assertEqual(results[1].day, 2)
self.assertEqual(results[1].score, 1000)
self.assertEqual(results[1].user, "tjake")
# Test montly high range queries
prepared_query = self.session.prepare("SELECT * FROM {0}.monthlyhigh WHERE game=? AND year=? AND month=? and score >= ? and score <= ?".format(self.keyspace_name))
bound_query = prepared_query.bind(("Coup", 2015, 6, 2500, 3500))
results = self.session.execute(bound_query)
self.assertEquals(results[0].game, 'Coup')
self.assertEquals(results[0].year, 2015)
self.assertEquals(results[0].month, 6)
self.assertEquals(results[0].day, 20)
self.assertEquals(results[0].score, 3500)
self.assertEquals(results[0].user, "jbellis")
self.assertEqual(results[0].game, 'Coup')
self.assertEqual(results[0].year, 2015)
self.assertEqual(results[0].month, 6)
self.assertEqual(results[0].day, 20)
self.assertEqual(results[0].score, 3500)
self.assertEqual(results[0].user, "jbellis")
self.assertEquals(results[1].game, 'Coup')
self.assertEquals(results[1].year, 2015)
self.assertEquals(results[1].month, 6)
self.assertEquals(results[1].day, 9)
self.assertEquals(results[1].score, 2700)
self.assertEquals(results[1].user, "jmckenzie")
self.assertEqual(results[1].game, 'Coup')
self.assertEqual(results[1].year, 2015)
self.assertEqual(results[1].month, 6)
self.assertEqual(results[1].day, 9)
self.assertEqual(results[1].score, 2700)
self.assertEqual(results[1].user, "jmckenzie")
self.assertEquals(results[2].game, 'Coup')
self.assertEquals(results[2].year, 2015)
self.assertEquals(results[2].month, 6)
self.assertEquals(results[2].day, 1)
self.assertEquals(results[2].score, 2500)
self.assertEquals(results[2].user, "iamaleksey")
self.assertEqual(results[2].game, 'Coup')
self.assertEqual(results[2].year, 2015)
self.assertEqual(results[2].month, 6)
self.assertEqual(results[2].day, 1)
self.assertEqual(results[2].score, 2500)
self.assertEqual(results[2].user, "iamaleksey")
# Test filtered user high scores
query_statement = SimpleStatement("SELECT * FROM {0}.filtereduserhigh WHERE game='Chess'".format(self.keyspace_name),
consistency_level=ConsistencyLevel.QUORUM)
results = self.session.execute(query_statement)
self.assertEquals(results[0].game, 'Chess')
self.assertEquals(results[0].year, 2015)
self.assertEquals(results[0].month, 6)
self.assertEquals(results[0].day, 21)
self.assertEquals(results[0].score, 3500)
self.assertEquals(results[0].user, "jbellis")
self.assertEqual(results[0].game, 'Chess')
self.assertEqual(results[0].year, 2015)
self.assertEqual(results[0].month, 6)
self.assertEqual(results[0].day, 21)
self.assertEqual(results[0].score, 3500)
self.assertEqual(results[0].user, "jbellis")
self.assertEquals(results[1].game, 'Chess')
self.assertEquals(results[1].year, 2015)
self.assertEquals(results[1].month, 1)
self.assertEquals(results[1].day, 25)
self.assertEquals(results[1].score, 3200)
self.assertEquals(results[1].user, "pcmanus")
self.assertEqual(results[1].game, 'Chess')
self.assertEqual(results[1].year, 2015)
self.assertEqual(results[1].month, 1)
self.assertEqual(results[1].day, 25)
self.assertEqual(results[1].score, 3200)
self.assertEqual(results[1].user, "pcmanus")
class UnicodeQueryTest(BasicSharedKeyspaceUnitTestCase):