Another batch of code coverage tests

tests/integration/test_query.py

@@ -44,3 +44,129 @@ class QueryTest(unittest.TestCase):
         str(statement.trace)
         for event in statement.trace.events:
             str(event)
+
+class PreparedStatementTests(unittest.TestCase):
+
+    def test_routing_key(self):
+        """
+        Simple code coverage to ensure routing_keys can be accessed
+        """
+
+        cluster = Cluster()
+        session = cluster.connect()
+
+        prepared = session.prepare(
+            """
+            INSERT INTO test3rf.test (k, v) VALUES  (?, ?)
+            """)
+
+        self.assertIsInstance(prepared, PreparedStatement)
+        bound = prepared.bind((1, None))
+        self.assertEqual(bound.routing_key, '\x00\x00\x00\x01')
+
+    def test_empty_routing_key_indexes(self):
+        """
+        Ensure when routing_key_indexes are blank,
+        the routing key should be None
+        """
+
+        cluster = Cluster()
+        session = cluster.connect()
+
+        prepared = session.prepare(
+            """
+            INSERT INTO test3rf.test (k, v) VALUES  (?, ?)
+            """)
+        prepared.routing_key_indexes = None
+
+        self.assertIsInstance(prepared, PreparedStatement)
+        bound = prepared.bind((1, None))
+        self.assertEqual(bound.routing_key, None)
+
+    def test_predefined_routing_key(self):
+        """
+        Basic test that ensures _set_routing_key()
+        overrides the current routing key
+        """
+
+        cluster = Cluster()
+        session = cluster.connect()
+
+        prepared = session.prepare(
+            """
+            INSERT INTO test3rf.test (k, v) VALUES  (?, ?)
+            """)
+
+        self.assertIsInstance(prepared, PreparedStatement)
+        bound = prepared.bind((1, None))
+        bound._set_routing_key('fake_key')
+        self.assertEqual(bound.routing_key, 'fake_key')
+
+    def test_multiple_routing_key_indexes(self):
+        """
+        Basic test that uses a fake routing_key_index
+        """
+
+        cluster = Cluster()
+        session = cluster.connect()
+
+        prepared = session.prepare(
+            """
+            INSERT INTO test3rf.test (k, v) VALUES  (?, ?)
+            """)
+        prepared.routing_key_indexes = {0: {0: 0}, 1: {1: 1}}
+
+        self.assertIsInstance(prepared, PreparedStatement)
+        bound = prepared.bind((1, 2))
+        self.assertEqual(bound.routing_key, '\x04\x00\x00\x00\x04\x00\x00\x00')
+
+    def test_bound_keyspace(self):
+        """
+        Ensure that bound.keyspace works as expected
+        """
+
+        cluster = Cluster()
+        session = cluster.connect()
+
+        prepared = session.prepare(
+            """
+            INSERT INTO test3rf.test (k, v) VALUES  (?, ?)
+            """)
+
+        self.assertIsInstance(prepared, PreparedStatement)
+        bound = prepared.bind((1, 2))
+        self.assertEqual(bound.keyspace, 'test3rf')
+
+        bound.prepared_statement.column_metadata = None
+        self.assertEqual(bound.keyspace, None)
+
+class PrintStatementTests(unittest.TestCase):
+    """
+    Test that shows the format used when printing Statements
+    """
+
+    def test_simple_statement(self):
+        """
+        Highlight the format of printing SimpleStatements
+        """
+
+        ss = SimpleStatement('SELECT * FROM test3rf.test')
+        self.assertEqual(str(ss),
+                         '<SimpleStatement query="SELECT * FROM test3rf.test", consistency=ONE>')
+
+    def test_prepared_statement(self):
+        """
+        Highlight the difference between Prepared and Bound statements
+        """
+
+        cluster = Cluster()
+        session = cluster.connect()
+
+        prepared = session.prepare('INSERT INTO test3rf.test (k, v) VALUES (?, ?)')
+
+        self.assertEqual(str(prepared),
+                         '<PreparedStatement query="INSERT INTO test3rf.test (k, v) VALUES (?, ?)", consistency=ONE>')
+
+        bound = prepared.bind((1, 2))
+        self.assertEqual(str(bound),
+                         '<BoundStatement query="INSERT INTO test3rf.test (k, v) VALUES (?, ?)", values=(1, 2), consistency=ONE>')

tests/unit/test_connection.py

@@ -93,7 +93,7 @@ class ConnectionTest(unittest.TestCase):
         c.defunct = Mock()
 
         # read in a SupportedMessage response
-        header = self.make_header_prefix(SupportedMessage, version=0x04)
+        header = self.make_header_prefix(SupportedMessage)
         options = self.make_options_body()
         message = self.make_msg(header, options)
         c.process_msg(message, -13)
@@ -127,3 +127,18 @@ class ConnectionTest(unittest.TestCase):
         c.defunct.assert_called_once_with(ANY)
         args, kwargs = c.defunct.call_args
         self.assertIsInstance(args[0], ProtocolError)
+
+    def test_not_implemented(self):
+        """
+        Ensure the following methods throw NIE's. If not, come back and test them.
+        """
+
+        c  = self.make_connection()
+
+        self.assertRaises(NotImplementedError, c.close)
+        self.assertRaises(NotImplementedError, c.defunct, None)
+        self.assertRaises(NotImplementedError, c.send_msg, None, None)
+        self.assertRaises(NotImplementedError, c.wait_for_response, None)
+        self.assertRaises(NotImplementedError, c.wait_for_responses)
+        self.assertRaises(NotImplementedError, c.register_watcher, None, None)
+        self.assertRaises(NotImplementedError, c.register_watchers, None)

tests/unit/test_metadata.py

@@ -1,10 +1,62 @@
 import unittest
 import cassandra
 from cassandra.cluster import Cluster
-from cassandra.metadata import TableMetadata, Murmur3Token, MD5Token, BytesToken
+from cassandra.metadata import TableMetadata, Murmur3Token, MD5Token, BytesToken, ReplicationStrategy, NetworkTopologyStrategy, SimpleStrategy, LocalStrategy
+from cassandra.policies import SimpleConvictionPolicy
+from cassandra.pool import Host
 
 
-class TestMetadata(unittest.TestCase):
+class TestStrategies(unittest.TestCase):
+
+    def test_replication_strategy(self):
+        """
+        Basic code coverage testing that ensures different ReplicationStrategies
+        can be initiated using parameters correctly.
+        """
+
+        rs = ReplicationStrategy()
+
+        self.assertEqual(rs.create('OldNetworkTopologyStrategy', None), None)
+        self.assertEqual(rs.create('xxxxxxOldNetworkTopologyStrategy', None), None)
+
+        fake_options_map = {'options': 'map'}
+        self.assertIsInstance(rs.create('NetworkTopologyStrategy', fake_options_map), NetworkTopologyStrategy)
+        self.assertEqual(rs.create('NetworkTopologyStrategy', fake_options_map).dc_replication_factors,
+                         NetworkTopologyStrategy(fake_options_map).dc_replication_factors)
+
+        self.assertIsInstance(rs.create('xxxxxxNetworkTopologyStrategy', fake_options_map), NetworkTopologyStrategy)
+        self.assertEqual(rs.create('xxxxxxNetworkTopologyStrategy', fake_options_map).dc_replication_factors,
+                         NetworkTopologyStrategy(fake_options_map).dc_replication_factors)
+
+        fake_options_map = {'options': 'map'}
+        self.assertEqual(rs.create('SimpleStrategy', fake_options_map), None)
+        self.assertEqual(rs.create('xxxxxxSimpleStrategy', fake_options_map), None)
+
+        fake_options_map = {'options': 'map'}
+        self.assertIsInstance(rs.create('LocalStrategy', fake_options_map), LocalStrategy)
+        self.assertIsInstance(rs.create('xxxxxxLocalStrategy', fake_options_map), LocalStrategy)
+
+        fake_options_map = {'options': 'map', 'replication_factor': 3}
+        self.assertIsInstance(rs.create('SimpleStrategy', fake_options_map), SimpleStrategy)
+        self.assertEqual(rs.create('SimpleStrategy', fake_options_map).replication_factor,
+                         SimpleStrategy(fake_options_map['replication_factor']).replication_factor)
+
+        self.assertIsInstance(rs.create('xxxxxxSimpleStrategy', fake_options_map), SimpleStrategy)
+        self.assertEqual(rs.create('xxxxxxSimpleStrategy', fake_options_map).replication_factor,
+                         SimpleStrategy(fake_options_map['replication_factor']).replication_factor)
+
+        self.assertEqual(rs.create('xxxxxxxx', fake_options_map), None)
+
+        self.assertRaises(NotImplementedError, rs.make_token_replica_map, None, None)
+        self.assertRaises(NotImplementedError, rs.export_for_schema)
+
+    def test_nts(self):
+        # TODO: Cover NetworkTopologyStrategy.make_token_replica_map()
+        # TODO: Cover NetworkTopologyStrategy.export_for_schema()
+        pass
+
+
+class TestTokens(unittest.TestCase):
 
     def test_protect_name(self):
         """
@@ -84,15 +136,18 @@ class TestMetadata(unittest.TestCase):
         murmur3_token = Murmur3Token(cassandra.metadata.MIN_LONG - 1)
         self.assertEqual(murmur3_token.hash_fn('123'), -7468325962851647638)
         self.assertEqual(murmur3_token.hash_fn(str(cassandra.metadata.MAX_LONG)), 7162290910810015547)
+        self.assertEqual(str(murmur3_token), '<Murmur3Token: -9223372036854775809L')
 
         md5_token = MD5Token(cassandra.metadata.MIN_LONG - 1)
         self.assertEqual(md5_token.hash_fn('123'), 42767516990368493138776584305024125808L)
         self.assertEqual(md5_token.hash_fn(str(cassandra.metadata.MAX_LONG)), 28528976619278518853815276204542453639L)
+        self.assertEqual(str(md5_token), '<MD5Token: -9223372036854775809')
 
         bytes_token = BytesToken(str(cassandra.metadata.MIN_LONG - 1))
         self.assertEqual(bytes_token.hash_fn('123'), '123')
         self.assertEqual(bytes_token.hash_fn(123), 123)
         self.assertEqual(bytes_token.hash_fn(str(cassandra.metadata.MAX_LONG)), str(cassandra.metadata.MAX_LONG))
+        self.assertEqual(str(bytes_token), "<BytesToken: '-9223372036854775809'")
 
         try:
             bytes_token = BytesToken(cassandra.metadata.MIN_LONG - 1)

tests/unit/test_policies.py

@@ -16,7 +16,7 @@ from cassandra.policies import (RoundRobinPolicy, DCAwareRoundRobinPolicy,
                                 HostDistance, ExponentialReconnectionPolicy,
                                 RetryPolicy, WriteType,
                                 DowngradingConsistencyRetryPolicy, ConstantReconnectionPolicy,
-                                LoadBalancingPolicy, ConvictionPolicy, ReconnectionPolicy)
+                                LoadBalancingPolicy, ConvictionPolicy, ReconnectionPolicy, FallthroughRetryPolicy)
 from cassandra.pool import Host
 from cassandra.query import Statement
 
@@ -32,7 +32,7 @@ class TestLoadBalancingPolicy(unittest.TestCase):
         host.set_location_info("dc1", "rack1")
 
         self.assertRaises(NotImplementedError, policy.distance, host)
-        self.assertRaises(NotImplementedError, policy.distance, host)
+        self.assertRaises(NotImplementedError, policy.populate, None, host)
         self.assertRaises(NotImplementedError, policy.make_query_plan)
         self.assertRaises(NotImplementedError, policy.on_up, host)
         self.assertRaises(NotImplementedError, policy.on_down, host)
@@ -322,6 +322,89 @@ class TokenAwarePolicyTest(unittest.TestCase):
             self.assertEquals(qplan[2].datacenter, "dc2")
             self.assertEquals(3, len(qplan))
 
+    class FakeCluster:
+        def __init__(self):
+            self.metadata = None
+
+    def test_get_distance(self):
+        """
+        Same test as DCAwareRoundRobinPolicyTest.test_get_distance()
+        Except a FakeCluster is needed for the metadata variable and
+        policy.child_policy is needed to change child policy settings
+        """
+
+        policy = TokenAwarePolicy(DCAwareRoundRobinPolicy("dc1", used_hosts_per_remote_dc=0))
+        host = Host("ip1", SimpleConvictionPolicy)
+        host.set_location_info("dc1", "rack1")
+
+        policy.populate(self.FakeCluster(), [host])
+
+        self.assertEqual(policy.distance(host), HostDistance.LOCAL)
+
+        # used_hosts_per_remote_dc is set to 0, so ignore it
+        remote_host = Host("ip2", SimpleConvictionPolicy)
+        remote_host.set_location_info("dc2", "rack1")
+        self.assertEqual(policy.distance(remote_host), HostDistance.IGNORED)
+
+        # dc2 isn't registered in the policy's live_hosts dict
+        policy.child_policy.used_hosts_per_remote_dc = 1
+        self.assertEqual(policy.distance(remote_host), HostDistance.IGNORED)
+
+        # make sure the policy has both dcs registered
+        policy.populate(self.FakeCluster(), [host, remote_host])
+        self.assertEqual(policy.distance(remote_host), HostDistance.REMOTE)
+
+        # since used_hosts_per_remote_dc is set to 1, only the first
+        # remote host in dc2 will be REMOTE, the rest are IGNORED
+        second_remote_host = Host("ip3", SimpleConvictionPolicy)
+        second_remote_host.set_location_info("dc2", "rack1")
+        policy.populate(self.FakeCluster(), [host, remote_host, second_remote_host])
+        distances = set([policy.distance(remote_host), policy.distance(second_remote_host)])
+        self.assertEqual(distances, set([HostDistance.REMOTE, HostDistance.IGNORED]))
+
+
+    def test_status_updates(self):
+        """
+        Same test as DCAwareRoundRobinPolicyTest.test_status_updates()
+        """
+
+        hosts = [Host(i, SimpleConvictionPolicy) for i in range(4)]
+        for h in hosts[:2]:
+            h.set_location_info("dc1", "rack1")
+        for h in hosts[2:]:
+            h.set_location_info("dc2", "rack1")
+
+        policy = TokenAwarePolicy(DCAwareRoundRobinPolicy("dc1", used_hosts_per_remote_dc=1))
+        policy.populate(self.FakeCluster(), hosts)
+        policy.on_down(hosts[0])
+        policy.on_remove(hosts[2])
+
+        new_local_host = Host(4, SimpleConvictionPolicy)
+        new_local_host.set_location_info("dc1", "rack1")
+        policy.on_up(new_local_host)
+
+        new_remote_host = Host(5, SimpleConvictionPolicy)
+        new_remote_host.set_location_info("dc9000", "rack1")
+        policy.on_add(new_remote_host)
+
+        # we now have two local hosts and two remote hosts in separate dcs
+        qplan = list(policy.make_query_plan())
+        self.assertEqual(set(qplan[:2]), set([hosts[1], new_local_host]))
+        self.assertEqual(set(qplan[2:]), set([hosts[3], new_remote_host]))
+
+        # since we have hosts in dc9000, the distance shouldn't be IGNORED
+        self.assertEqual(policy.distance(new_remote_host), HostDistance.REMOTE)
+
+        policy.on_down(new_local_host)
+        policy.on_down(hosts[1])
+        qplan = list(policy.make_query_plan())
+        self.assertEqual(set(qplan), set([hosts[3], new_remote_host]))
+
+        policy.on_down(new_remote_host)
+        policy.on_down(hosts[3])
+        qplan = list(policy.make_query_plan())
+        self.assertEqual(qplan, [])
+
 class ConvictionPolicyTest(unittest.TestCase):
     def test_not_implemented(self):
         """
@@ -468,6 +551,106 @@ class RetryPolicyTest(unittest.TestCase):
         self.assertEqual(retry, RetryPolicy.RETRY)
         self.assertEqual(consistency, 'ONE')
 
+    def test_unavailable(self):
+        """
+        Use the same tests for test_write_timeout, but ensure they only RETHROW
+        """
+        policy = RetryPolicy()
+
+        retry, consistency = policy.on_unavailable(
+            query=None, consistency="ONE",
+            required_replicas=1, alive_replicas=2, retry_num=1)
+        self.assertEqual(retry, RetryPolicy.RETHROW)
+        self.assertEqual(consistency, None)
+
+        retry, consistency = policy.on_unavailable(
+            query=None, consistency="ONE",
+            required_replicas=1, alive_replicas=2, retry_num=0)
+        self.assertEqual(retry, RetryPolicy.RETHROW)
+        self.assertEqual(consistency, None)
+
+        retry, consistency = policy.on_unavailable(
+            query=None, consistency="ONE",
+            required_replicas=10000, alive_replicas=1, retry_num=0)
+        self.assertEqual(retry, RetryPolicy.RETHROW)
+        self.assertEqual(consistency, None)
+
+
+class FallthroughRetryPolicyTest(unittest.TestCase):
+
+    """
+    Use the same tests for test_write_timeout, but ensure they only RETHROW
+    """
+
+    def test_read_timeout(self):
+        policy = FallthroughRetryPolicy()
+
+        retry, consistency = policy.on_read_timeout(
+            query=None, consistency="ONE", required_responses=1, received_responses=2,
+            data_retrieved=True, retry_num=1)
+        self.assertEqual(retry, RetryPolicy.RETHROW)
+        self.assertEqual(consistency, None)
+
+        retry, consistency = policy.on_read_timeout(
+            query=None, consistency="ONE", required_responses=2, received_responses=1,
+            data_retrieved=True, retry_num=0)
+        self.assertEqual(retry, RetryPolicy.RETHROW)
+        self.assertEqual(consistency, None)
+
+        retry, consistency = policy.on_read_timeout(
+            query=None, consistency="ONE", required_responses=2, received_responses=2,
+            data_retrieved=True, retry_num=0)
+        self.assertEqual(retry, RetryPolicy.RETHROW)
+        self.assertEqual(consistency, None)
+
+        retry, consistency = policy.on_read_timeout(
+            query=None, consistency="ONE", required_responses=2, received_responses=2,
+            data_retrieved=False, retry_num=0)
+        self.assertEqual(retry, RetryPolicy.RETHROW)
+        self.assertEqual(consistency, None)
+
+    def test_write_timeout(self):
+        policy = FallthroughRetryPolicy()
+
+        retry, consistency = policy.on_write_timeout(
+            query=None, consistency="ONE", write_type=WriteType.SIMPLE,
+            required_responses=1, received_responses=2, retry_num=1)
+        self.assertEqual(retry, RetryPolicy.RETHROW)
+        self.assertEqual(consistency, None)
+
+        retry, consistency = policy.on_write_timeout(
+            query=None, consistency="ONE", write_type=WriteType.SIMPLE,
+            required_responses=1, received_responses=2, retry_num=0)
+        self.assertEqual(retry, RetryPolicy.RETHROW)
+        self.assertEqual(consistency, None)
+
+        retry, consistency = policy.on_write_timeout(
+            query=None, consistency="ONE", write_type=WriteType.BATCH_LOG,
+            required_responses=10000, received_responses=1, retry_num=0)
+        self.assertEqual(retry, RetryPolicy.RETHROW)
+        self.assertEqual(consistency, None)
+
+    def test_unavailable(self):
+        policy = FallthroughRetryPolicy()
+
+        retry, consistency = policy.on_unavailable(
+            query=None, consistency="ONE",
+            required_replicas=1, alive_replicas=2, retry_num=1)
+        self.assertEqual(retry, RetryPolicy.RETHROW)
+        self.assertEqual(consistency, None)
+
+        retry, consistency = policy.on_unavailable(
+            query=None, consistency="ONE",
+            required_replicas=1, alive_replicas=2, retry_num=0)
+        self.assertEqual(retry, RetryPolicy.RETHROW)
+        self.assertEqual(consistency, None)
+
+        retry, consistency = policy.on_unavailable(
+            query=None, consistency="ONE",
+            required_replicas=10000, alive_replicas=1, retry_num=0)
+        self.assertEqual(retry, RetryPolicy.RETHROW)
+        self.assertEqual(consistency, None)
+
 
 class DowngradingConsistencyRetryPolicyTest(unittest.TestCase):