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

assertEquals is deprecated, use assertEqual

Browse Source
This commit is contained in:
Tyler Hobbs
2014-03-26 14:53:43 -05:00
parent b56ad8587d
commit be1b55a2e9
11 changed files with 67 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
tests/integration/standard/test_cluster.py
View File

@@ -25,7 +25,7 @@ class ClusterTests(unittest.TestCase):
CREATE KEYSPACE clustertests
WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}
""")
self.assertEquals(None, result)
self.assertEqual(None, result)
result = session.execute(
"""
@@ -36,16 +36,16 @@ class ClusterTests(unittest.TestCase):
PRIMARY KEY (a, b)
)
""")
self.assertEquals(None, result)
self.assertEqual(None, result)
result = session.execute(
"""
INSERT INTO clustertests.cf0 (a, b, c) VALUES ('a', 'b', 'c')
""")
self.assertEquals(None, result)
self.assertEqual(None, result)
result = session.execute("SELECT * FROM clustertests.cf0")
self.assertEquals([('a', 'b', 'c')], result)
self.assertEqual([('a', 'b', 'c')], result)
cluster.shutdown()
@@ -60,15 +60,15 @@ class ClusterTests(unittest.TestCase):
"""
INSERT INTO test3rf.test (k, v) VALUES (8889, 8889)
""")
self.assertEquals(None, result)
self.assertEqual(None, result)
result = session.execute("SELECT * FROM test3rf.test")
self.assertEquals([(8889, 8889)], result)
self.assertEqual([(8889, 8889)], result)
# test_connect_on_keyspace
session2 = cluster.connect('test3rf')
result2 = session2.execute("SELECT * FROM test")
self.assertEquals(result, result2)
self.assertEqual(result, result2)
def test_set_keyspace_twice(self):
cluster = Cluster()

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

@@ -101,7 +101,7 @@ class SchemaMetadataTest(unittest.TestCase):
def check_create_statement(self, tablemeta, original):
recreate = tablemeta.as_cql_query(formatted=False)
self.assertEquals(original, recreate[:len(original)])
self.assertEqual(original, recreate[:len(original)])
self.session.execute("DROP TABLE %s.%s" % (self.ksname, self.cfname))
self.session.execute(recreate)

9
tests/integration/standard/test_prepared_statements.py
View File

@@ -7,6 +7,7 @@ from cassandra import InvalidRequest
from cassandra.cluster import Cluster
from cassandra.query import PreparedStatement
class PreparedStatementTests(unittest.TestCase):
def test_basic(self):
@@ -51,7 +52,7 @@ class PreparedStatementTests(unittest.TestCase):
bound = prepared.bind(('a'))
results = session.execute(bound)
self.assertEquals(results, [('a', 'b', 'c')])
self.assertEqual(results, [('a', 'b', 'c')])
def test_missing_primary_key(self):
"""
@@ -85,7 +86,7 @@ class PreparedStatementTests(unittest.TestCase):
""")
self.assertIsInstance(prepared, PreparedStatement)
self.assertRaises(ValueError, prepared.bind, (1,2))
self.assertRaises(ValueError, prepared.bind, (1, 2))
def test_none_values(self):
"""
@@ -112,7 +113,7 @@ class PreparedStatementTests(unittest.TestCase):
bound = prepared.bind((1,))
results = session.execute(bound)
self.assertEquals(results[0].v, None)
self.assertEqual(results[0].v, None)
def test_async_binding(self):
"""
@@ -139,4 +140,4 @@ class PreparedStatementTests(unittest.TestCase):
future = session.execute_async(prepared, (873,))
results = future.result()
self.assertEquals(results[0].v, None)
self.assertEqual(results[0].v, None)

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

@@ -288,14 +288,14 @@ class SerialConsistencyTests(unittest.TestCase):
"UPDATE test3rf.test SET v=1 WHERE k=0 IF v=1",
serial_consistency_level=ConsistencyLevel.SERIAL)
result = self.session.execute(statement)
self.assertEquals(1, len(result))
self.assertEqual(1, len(result))
self.assertFalse(result[0].applied)
statement = SimpleStatement(
"UPDATE test3rf.test SET v=1 WHERE k=0 IF v=0",
serial_consistency_level=ConsistencyLevel.SERIAL)
result = self.session.execute(statement)
self.assertEquals(1, len(result))
self.assertEqual(1, len(result))
self.assertTrue(result[0].applied)
def test_conditional_update_with_prepared_statements(self):
@@ -305,7 +305,7 @@ class SerialConsistencyTests(unittest.TestCase):
statement.serial_consistency_level = ConsistencyLevel.SERIAL
result = self.session.execute(statement)
self.assertEquals(1, len(result))
self.assertEqual(1, len(result))
self.assertFalse(result[0].applied)
statement = self.session.prepare(
@@ -313,7 +313,7 @@ class SerialConsistencyTests(unittest.TestCase):
bound = statement.bind(())
bound.serial_consistency_level = ConsistencyLevel.SERIAL
result = self.session.execute(statement)
self.assertEquals(1, len(result))
self.assertEqual(1, len(result))
self.assertTrue(result[0].applied)
def test_bad_consistency_level(self):

20
tests/integration/standard/test_types.py
View File

@@ -66,7 +66,7 @@ class TypeTests(unittest.TestCase):
results = s.execute("SELECT * FROM mytable")
for expected, actual in zip(expected_vals, results[0]):
self.assertEquals(expected, actual)
self.assertEqual(expected, actual)
def test_blob_type_as_bytearray(self):
c = Cluster()
@@ -101,7 +101,7 @@ class TypeTests(unittest.TestCase):
results = s.execute("SELECT * FROM mytable")
for expected, actual in zip(expected_vals, results[0]):
self.assertEquals(expected, actual)
self.assertEqual(expected, actual)
create_type_table = """
CREATE TABLE mytable (
@@ -194,7 +194,7 @@ class TypeTests(unittest.TestCase):
results = s.execute("SELECT * FROM mytable")
for expected, actual in zip(expected_vals, results[0]):
self.assertEquals(expected, actual)
self.assertEqual(expected, actual)
# try the same thing with a prepared statement
prepared = s.prepare("""
@@ -207,7 +207,7 @@ class TypeTests(unittest.TestCase):
results = s.execute("SELECT * FROM mytable")
for expected, actual in zip(expected_vals, results[0]):
self.assertEquals(expected, actual)
self.assertEqual(expected, actual)
# query with prepared statement
prepared = s.prepare("""
@@ -216,14 +216,14 @@ class TypeTests(unittest.TestCase):
results = s.execute(prepared.bind(()))
for expected, actual in zip(expected_vals, results[0]):
self.assertEquals(expected, actual)
self.assertEqual(expected, actual)
# query with prepared statement, no explicit columns
prepared = s.prepare("""SELECT * FROM mytable""")
results = s.execute(prepared.bind(()))
for expected, actual in zip(expected_vals, results[0]):
self.assertEquals(expected, actual)
self.assertEqual(expected, actual)
def test_empty_strings_and_nones(self):
c = Cluster()
@@ -251,11 +251,11 @@ class TypeTests(unittest.TestCase):
# insert empty strings for string-like fields and fetch them
s.execute("INSERT INTO mytable (a, b, c, o, s, l, n) VALUES ('a', 'b', %s, %s, %s, %s, %s)",
('', '', '', [''], {'': 3}))
self.assertEquals(
self.assertEqual(
{'c': '', 'o': '', 's': '', 'l': ('', ), 'n': OrderedDict({'': 3})},
s.execute("SELECT c, o, s, l, n FROM mytable WHERE a='a' AND b='b'")[0])
self.assertEquals(
self.assertEqual(
{'c': '', 'o': '', 's': '', 'l': ('', ), 'n': OrderedDict({'': 3})},
s.execute(s.prepare("SELECT c, o, s, l, n FROM mytable WHERE a='a' AND b='b'"), [])[0])
@@ -367,10 +367,10 @@ class TypeTests(unittest.TestCase):
# test non-prepared statement
s.execute("INSERT INTO mytable (a, b) VALUES ('key1', %s)", parameters=(dt,))
result = s.execute("SELECT b FROM mytable WHERE a='key1'")[0].b
self.assertEquals(dt.utctimetuple(), result.utctimetuple())
self.assertEqual(dt.utctimetuple(), result.utctimetuple())
# test prepared statement
prepared = s.prepare("INSERT INTO mytable (a, b) VALUES ('key2', ?)")
s.execute(prepared, parameters=(dt,))
result = s.execute("SELECT b FROM mytable WHERE a='key2'")[0].b
self.assertEquals(dt.utctimetuple(), result.utctimetuple())
self.assertEqual(dt.utctimetuple(), result.utctimetuple())

16
tests/unit/io/test_asyncorereactor.py
View File

@@ -20,7 +20,7 @@ from cassandra.connection import (HEADER_DIRECTION_TO_CLIENT,
from cassandra.decoder import (write_stringmultimap, write_int, write_string,
SupportedMessage, ReadyMessage, ServerError)
from cassandra.marshal import uint8_pack, uint8_unpack, uint32_pack, int32_pack
from cassandra.marshal import uint8_pack, uint32_pack, int32_pack
from cassandra.io.asyncorereactor import AsyncoreConnection
@@ -112,17 +112,17 @@ class AsyncoreConnectionTest(unittest.TestCase):
c.socket.recv.side_effect = side_effect
c.handle_read()
self.assertEquals(c._total_reqd_bytes, 20000 + len(header))
self.assertEqual(c._total_reqd_bytes, 20000 + len(header))
# the EAGAIN prevents it from reading the last 100 bytes
c._iobuf.seek(0, os.SEEK_END)
pos = c._iobuf.tell()
self.assertEquals(pos, 4096 + 4096)
self.assertEqual(pos, 4096 + 4096)
# now tell it to read the last 100 bytes
c.handle_read()
c._iobuf.seek(0, os.SEEK_END)
pos = c._iobuf.tell()
self.assertEquals(pos, 4096 + 4096 + 100)
self.assertEqual(pos, 4096 + 4096 + 100)
def test_protocol_error(self, *args):
c = self.make_connection()
@@ -229,11 +229,11 @@ class AsyncoreConnectionTest(unittest.TestCase):
c.socket.recv.return_value = message[0:1]
c.handle_read()
self.assertEquals(c._iobuf.getvalue(), message[0:1])
self.assertEqual(c._iobuf.getvalue(), message[0:1])
c.socket.recv.return_value = message[1:]
c.handle_read()
self.assertEquals(six.binary_type(), c._iobuf.getvalue())
self.assertEqual(six.binary_type(), c._iobuf.getvalue())
# let it write out a StartupMessage
c.handle_write()
@@ -255,12 +255,12 @@ class AsyncoreConnectionTest(unittest.TestCase):
# read in the first nine bytes
c.socket.recv.return_value = message[:9]
c.handle_read()
self.assertEquals(c._iobuf.getvalue(), message[:9])
self.assertEqual(c._iobuf.getvalue(), message[:9])
# ... then read in the rest
c.socket.recv.return_value = message[9:]
c.handle_read()
self.assertEquals(six.binary_type(), c._iobuf.getvalue())
self.assertEqual(six.binary_type(), c._iobuf.getvalue())
# let it write out a StartupMessage
c.handle_write()

14
tests/unit/io/test_libevreactor.py
View File

@@ -110,17 +110,17 @@ class LibevConnectionTest(unittest.TestCase):
c._socket.recv.side_effect = side_effect
c.handle_read(None, 0)
self.assertEquals(c._total_reqd_bytes, 20000 + len(header))
self.assertEqual(c._total_reqd_bytes, 20000 + len(header))
# the EAGAIN prevents it from reading the last 100 bytes
c._iobuf.seek(0, os.SEEK_END)
pos = c._iobuf.tell()
self.assertEquals(pos, 4096 + 4096)
self.assertEqual(pos, 4096 + 4096)
# now tell it to read the last 100 bytes
c.handle_read(None, 0)
c._iobuf.seek(0, os.SEEK_END)
pos = c._iobuf.tell()
self.assertEquals(pos, 4096 + 4096 + 100)
self.assertEqual(pos, 4096 + 4096 + 100)
def test_protocol_error(self, *args):
c = self.make_connection()
@@ -228,11 +228,11 @@ class LibevConnectionTest(unittest.TestCase):
# read in the first byte
c._socket.recv.return_value = message[0]
c.handle_read(None, 0)
self.assertEquals(c._iobuf.getvalue(), message[0])
self.assertEqual(c._iobuf.getvalue(), message[0])
c._socket.recv.return_value = message[1:]
c.handle_read(None, 0)
self.assertEquals("", c._iobuf.getvalue())
self.assertEqual("", c._iobuf.getvalue())
# let it write out a StartupMessage
c.handle_write(None, 0)
@@ -254,12 +254,12 @@ class LibevConnectionTest(unittest.TestCase):
# read in the first nine bytes
c._socket.recv.return_value = message[:9]
c.handle_read(None, 0)
self.assertEquals(c._iobuf.getvalue(), message[:9])
self.assertEqual(c._iobuf.getvalue(), message[:9])
# ... then read in the rest
c._socket.recv.return_value = message[9:]
c.handle_read(None, 0)
self.assertEquals("", c._iobuf.getvalue())
self.assertEqual("", c._iobuf.getvalue())
# let it write out a StartupMessage
c.handle_write(None, 0)

16
tests/unit/test_parameter_binding.py
View File

@@ -15,27 +15,27 @@ class ParamBindingTest(unittest.TestCase):
def test_bind_sequence(self):
result = bind_params("%s %s %s", (1, "a", 2.0))
self.assertEquals(result, "1 'a' 2.0")
self.assertEqual(result, "1 'a' 2.0")
def test_bind_map(self):
result = bind_params("%(a)s %(b)s %(c)s", dict(a=1, b="a", c=2.0))
self.assertEquals(result, "1 'a' 2.0")
self.assertEqual(result, "1 'a' 2.0")
def test_sequence_param(self):
result = bind_params("%s", (ValueSequence((1, "a", 2.0)),))
self.assertEquals(result, "( 1 , 'a' , 2.0 )")
self.assertEqual(result, "( 1 , 'a' , 2.0 )")
def test_generator_param(self):
result = bind_params("%s", ((i for i in xrange(3)),))
self.assertEquals(result, "[ 0 , 1 , 2 ]")
self.assertEqual(result, "[ 0 , 1 , 2 ]")
def test_none_param(self):
result = bind_params("%s", (None,))
self.assertEquals(result, "NULL")
self.assertEqual(result, "NULL")
def test_list_collection(self):
result = bind_params("%s", (['a', 'b', 'c'],))
self.assertEquals(result, "[ 'a' , 'b' , 'c' ]")
self.assertEqual(result, "[ 'a' , 'b' , 'c' ]")
def test_set_collection(self):
result = bind_params("%s", (set(['a', 'b']),))
@@ -47,11 +47,11 @@ class ParamBindingTest(unittest.TestCase):
vals['b'] = 'b'
vals['c'] = 'c'
result = bind_params("%s", (vals,))
self.assertEquals(result, "{ 'a' : 'a' , 'b' : 'b' , 'c' : 'c' }")
self.assertEqual(result, "{ 'a' : 'a' , 'b' : 'b' , 'c' : 'c' }")
def test_quote_escaping(self):
result = bind_params("%s", ("""'ef''ef"ef""ef'""",))
self.assertEquals(result, """'''ef''''ef"ef""ef'''""")
self.assertEqual(result, """'''ef''''ef"ef""ef'''""")
class BoundStatementTestCase(unittest.TestCase):

14
tests/unit/test_policies.py
View File

@@ -319,14 +319,14 @@ class TokenAwarePolicyTest(unittest.TestCase):
replicas = get_replicas(None, struct.pack('>i', i))
other = set(h for h in hosts if h not in replicas)
self.assertEquals(replicas, qplan[:2])
self.assertEquals(other, set(qplan[2:]))
self.assertEqual(replicas, qplan[:2])
self.assertEqual(other, set(qplan[2:]))
# Should use the secondary policy
for i in range(4):
qplan = list(policy.make_query_plan())
self.assertEquals(set(qplan), set(hosts))
self.assertEqual(set(qplan), set(hosts))
def test_wrap_dc_aware(self):
cluster = Mock(spec=Cluster)
@@ -359,16 +359,16 @@ class TokenAwarePolicyTest(unittest.TestCase):
# first should be the only local replica
self.assertIn(qplan[0], replicas)
self.assertEquals(qplan[0].datacenter, "dc1")
self.assertEqual(qplan[0].datacenter, "dc1")
# then the local non-replica
self.assertNotIn(qplan[1], replicas)
self.assertEquals(qplan[1].datacenter, "dc1")
self.assertEqual(qplan[1].datacenter, "dc1")
# then one of the remotes (used_hosts_per_remote_dc is 1, so we
# shouldn't see two remotes)
self.assertEquals(qplan[2].datacenter, "dc2")
self.assertEquals(3, len(qplan))
self.assertEqual(qplan[2].datacenter, "dc2")
self.assertEqual(3, len(qplan))
class FakeCluster:
def __init__(self):

8
tests/unit/test_response_future.py
View File

@@ -334,7 +334,7 @@ class ResponseFutureTests(unittest.TestCase):
rf.send_request()
rf.add_callbacks(
callback=self.assertEquals, callback_args=([{'col': 'val'}],),
callback=self.assertEqual, callback_args=([{'col': 'val'}],),
errback=self.assertIsInstance, errback_args=(Exception,))
result = Mock(spec=UnavailableErrorMessage, info={})
@@ -346,7 +346,7 @@ class ResponseFutureTests(unittest.TestCase):
rf.send_request()
rf.add_callbacks(
callback=self.assertEquals, callback_args=([{'col': 'val'}],),
callback=self.assertEqual, callback_args=([{'col': 'val'}],),
errback=self.assertIsInstance, errback_args=(Exception,))
response = Mock(spec=ResultMessage, kind=RESULT_KIND_ROWS, results=[{'col': 'val'}])
@@ -369,9 +369,9 @@ class ResponseFutureTests(unittest.TestCase):
session.submit.assert_called_once()
args, kwargs = session.submit.call_args
self.assertEquals(rf._reprepare, args[-2])
self.assertEqual(rf._reprepare, args[-2])
self.assertIsInstance(args[-1], PrepareMessage)
self.assertEquals(args[-1].query, "SELECT * FROM foobar")
self.assertEqual(args[-1].query, "SELECT * FROM foobar")
def test_prepared_query_not_found_bad_keyspace(self):
session = self.make_session()

12
tests/unit/test_types.py
View File

@@ -144,15 +144,15 @@ class TypeTests(unittest.TestCase):
'7a6970:org.apache.cassandra.db.marshal.UTF8Type',
')')))
self.assertEquals(FooType, ctype.__class__)
self.assertEqual(FooType, ctype.__class__)
self.assertEquals(UTF8Type, ctype.subtypes[0])
self.assertEqual(UTF8Type, ctype.subtypes[0])
# middle subtype should be a BarType instance with its own subtypes and names
self.assertIsInstance(ctype.subtypes[1], BarType)
self.assertEquals([UTF8Type], ctype.subtypes[1].subtypes)
self.assertEquals([b"address"], ctype.subtypes[1].names)
self.assertEqual([UTF8Type], ctype.subtypes[1].subtypes)
self.assertEqual([b"address"], ctype.subtypes[1].names)
self.assertEquals(UTF8Type, ctype.subtypes[2])
self.assertEqual(UTF8Type, ctype.subtypes[2])
self.assertEquals([b'city', None, b'zip'], ctype.names)
self.assertEqual([b'city', None, b'zip'], ctype.names)