Add cython protocol integration test

Mark Florisson · Mark Florisson · commit 99dea50c735d · 2015-08-04T16:50:29.000+01:00
diff --git a/.gitignore b/.gitignore
@@ -4,6 +4,7 @@
 *.so
 *.egg
 *.egg-info
+*.attr
 .tox
 .python-version
 build
@@ -19,6 +20,7 @@ setuptools*.egg
 
 cassandra/*.c
 !cassandra/murmur3.c
+cassandra/*.html
 
 # OSX
 .DS_Store
@@ -38,3 +40,4 @@ cassandra/*.c
 
 #iPython
 *.ipynb
+
diff --git a/tests/integration/standard/test_custom_protocol_handler.py b/tests/integration/standard/test_custom_protocol_handler.py
@@ -21,7 +21,8 @@
 from cassandra.query import tuple_factory
 from cassandra.cluster import Cluster
 from tests.integration import use_singledc, PROTOCOL_VERSION, execute_until_pass
-from tests.integration.datatype_utils import update_datatypes, PRIMITIVE_DATATYPES, get_sample
+from tests.integration.datatype_utils import update_datatypes, PRIMITIVE_DATATYPES
+from tests.integration.standard.utils import create_table_with_all_types, get_all_primitive_params
 from six import binary_type
 
 import uuid
@@ -106,55 +107,18 @@ def test_custom_raw_row_results_all_types(self):
         session.client_protocol_handler = CustomProtocolHandlerResultMessageTracked
         session.row_factory = tuple_factory
 
-        columns_string = create_table_with_all_types("test_table", session)
+        columns_string = create_table_with_all_types("alltypes", session)
 
         # verify data
         params = get_all_primitive_params()
-        results = session.execute("SELECT {0} FROM alltypes WHERE zz=0".format(columns_string))[0]
+        results = session.execute("SELECT {0} FROM alltypes WHERE pimkey=0".format(columns_string))[0]
         for expected, actual in zip(params, results):
             self.assertEqual(actual, expected)
         # Ensure we have covered the various primitive types
         self.assertEqual(len(CustomResultMessageTracked.checked_rev_row_set), len(PRIMITIVE_DATATYPES)-1)
         session.shutdown()
 
 
-def create_table_with_all_types(table_name, session):
-    """
-    Method that given a table_name and session construct a table that contains all possible primitive types
-    :param table_name: Name of table to create
-    :param session: session to use for table creation
-    :return: a string containing and columns. This can be used to query the table.
-    """
-    # create table
-    alpha_type_list = ["zz int PRIMARY KEY"]
-    col_names = ["zz"]
-    start_index = ord('a')
-    for i, datatype in enumerate(PRIMITIVE_DATATYPES):
-        alpha_type_list.append("{0} {1}".format(chr(start_index + i), datatype))
-        col_names.append(chr(start_index + i))
-
-    session.execute("CREATE TABLE alltypes ({0})".format(', '.join(alpha_type_list)), timeout=120)
-
-    # create the input
-    params = get_all_primitive_params()
-
-    # insert into table as a simple statement
-    columns_string = ', '.join(col_names)
-    placeholders = ', '.join(["%s"] * len(col_names))
-    session.execute("INSERT INTO alltypes ({0}) VALUES ({1})".format(columns_string, placeholders), params, timeout=120)
-    return columns_string
-
-
-def get_all_primitive_params():
-    """
-    Simple utility method used to give back a list of all possible primitive data sample types.
-    """
-    params = [0]
-    for datatype in PRIMITIVE_DATATYPES:
-        params.append((get_sample(datatype)))
-    return params
-
-
 class CustomResultMessageRaw(ResultMessage):
     """
     This is a custom Result Message that is used to return raw results, rather then
diff --git a/tests/integration/standard/test_cython_protocol_handlers.py b/tests/integration/standard/test_cython_protocol_handlers.py
@@ -0,0 +1,75 @@
+"""Test the various Cython-based message deserializers"""
+
+# Based on test_custom_protocol_handler.py
+
+try:
+    import unittest2 as unittest
+except ImportError:
+    import unittest
+
+from cassandra.cluster import Cluster
+from tests.integration import use_singledc, PROTOCOL_VERSION
+from tests.integration.datatype_utils import update_datatypes
+from tests.integration.standard.utils import create_table_with_all_types, get_all_primitive_params
+from six import next
+
+try:
+    from cassandra.cython_protocol_handler import make_protocol_handler
+except ImportError as e:
+    raise unittest.skip("Skipping test, not compiled with Cython enabled")
+
+from cassandra.numpyparser import NumpyParser
+from cassandra.objparser import ListParser, LazyParser
+
+
+def setup_module():
+    use_singledc()
+    update_datatypes()
+
+
+class CustomProtocolHandlerTest(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.cluster = Cluster(protocol_version=PROTOCOL_VERSION)
+        cls.session = cls.cluster.connect()
+        cls.session.execute("CREATE KEYSPACE testspace WITH replication = "
+                            "{ 'class' : 'SimpleStrategy', 'replication_factor': '1'}")
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.session.execute("DROP KEYSPACE testspace")
+        cls.cluster.shutdown()
+
+    def test_cython_parser(self):
+        """
+        Test Cython-based parser that returns a list of tuples
+        """
+        self.cython_parser(ListParser())
+
+    def test_cython_lazy_parser(self):
+        """
+        Test Cython-based parser that returns a list of tuples
+        """
+        self.cython_parser(LazyParser())
+
+    def cython_parser(self, colparser):
+        session = Cluster().connect()
+        session.set_keyspace("smallspace")
+
+        # use our custom protocol handler
+        session.client_protocol_handler = make_protocol_handler(colparser)
+        # session.row_factory = tuple_factory
+        create_table_with_all_types("test_table", session)
+
+        # verify data
+        params = get_all_primitive_params()
+        [first_result] = session.execute("SELECT * FROM test_table WHERE primkey=0")
+        self.assertEqual(len(params), len(first_result),
+                         msg="Not the right number of columns?")
+        print(first_result)
+        assert False
+        for expected, actual in zip(params, first_result):
+            self.assertEqual(actual, expected)
+
+        session.shutdown()
