merged tests/integration/standard/test_metadata.py

Author: aboudreault

tests/integration/standard/test_metadata.py

@@ -34,14 +34,16 @@
 from cassandra.metadata import (IndexMetadata, Token, murmur3, Function, Aggregate, protect_name, protect_names,
                                 RegisteredTableExtension, _RegisteredExtensionType, get_schema_parser,
                                 group_keys_by_replica, NO_VALID_REPLICA)
+from cassandra.util import SortedSet
 
 from tests.integration import (get_cluster, use_singledc, PROTOCOL_VERSION, execute_until_pass,
                                BasicSegregatedKeyspaceUnitTestCase, BasicSharedKeyspaceUnitTestCase,
                                BasicExistingKeyspaceUnitTestCase, drop_keyspace_shutdown_cluster, CASSANDRA_VERSION,
-                               get_supported_protocol_versions, greaterthanorequalcass30, lessthancass30, local,
-                               greaterthancass20, greaterthanorequalcass40)
-
-from tests.integration import greaterthancass21
+                               greaterthanorequaldse51, greaterthanorequalcass30, lessthancass30, local,
+                               get_supported_protocol_versions, greaterthancass20,
+                               greaterthancass21, assert_startswith, greaterthanorequalcass40,
+                               greaterthanorequaldse67, lessthancass40
+)
 
 
 log = logging.getLogger(__name__)
@@ -94,7 +96,8 @@ def test_host_release_version(self):
         @test_category metadata
         """
         for host in self.cluster.metadata.all_hosts():
-            self.assertTrue(host.release_version.startswith(CASSANDRA_VERSION.base_version))
+            assert_startswith(host.release_version, CASSANDRA_VERSION.base_version)
+
 
 
 @local
@@ -225,7 +228,12 @@ def test_basic_table_meta_properties(self):
         self.assertEqual([u'a', u'b', u'c'], sorted(tablemeta.columns.keys()))
 
         cc = self.cluster.control_connection._connection
-        parser = get_schema_parser(cc, CASSANDRA_VERSION.base_version, 1)
+        parser = get_schema_parser(
+            cc,
+            self.cluster.metadata.get_host(cc.host).release_version,
+            self.cluster.metadata.get_host(cc.host).dse_version,
+            1
+        )
 
         for option in tablemeta.options:
             self.assertIn(option, parser.recognized_table_options)
@@ -405,6 +413,7 @@ def test_composite_in_compound_primary_key_ordering(self):
         tablemeta = self.get_table_metadata()
         self.check_create_statement(tablemeta, create_statement)
 
+    @lessthancass40
     def test_compact_storage(self):
         create_statement = self.make_create_statement(["a"], [], ["b"])
         create_statement += " WITH COMPACT STORAGE"
@@ -413,6 +422,7 @@ def test_compact_storage(self):
         tablemeta = self.get_table_metadata()
         self.check_create_statement(tablemeta, create_statement)
 
+    @lessthancass40
     def test_dense_compact_storage(self):
         create_statement = self.make_create_statement(["a"], ["b"], ["c"])
         create_statement += " WITH COMPACT STORAGE"
@@ -431,6 +441,7 @@ def test_counter(self):
         tablemeta = self.get_table_metadata()
         self.check_create_statement(tablemeta, create_statement)
 
+    @lessthancass40
     def test_counter_with_compact_storage(self):
         """ PYTHON-1100 """
         create_statement = (
@@ -442,6 +453,7 @@ def test_counter_with_compact_storage(self):
         tablemeta = self.get_table_metadata()
         self.check_create_statement(tablemeta, create_statement)
 
+    @lessthancass40
     def test_counter_with_dense_compact_storage(self):
         create_statement = (
             "CREATE TABLE {keyspace}.{table} ("
@@ -558,7 +570,6 @@ def test_refresh_schema_metadata(self):
 
         @test_category metadata
         """
-
         cluster2 = Cluster(protocol_version=PROTOCOL_VERSION, schema_event_refresh_window=-1)
         cluster2.connect()
 
@@ -599,7 +610,7 @@ def test_refresh_schema_metadata(self):
             self.session.execute("""CREATE FUNCTION {0}.sum_int(key int, val int)
                                 RETURNS NULL ON NULL INPUT
                                 RETURNS int
-                                LANGUAGE javascript AS 'key + val';""".format(self.keyspace_name))
+                                LANGUAGE java AS 'return key+val;';""".format(self.keyspace_name))
 
             self.assertEqual(cluster2.metadata.keyspaces[self.keyspace_name].functions, {})
             cluster2.refresh_schema_metadata()
@@ -837,7 +848,7 @@ def test_refresh_user_function_metadata(self):
         self.session.execute("""CREATE FUNCTION {0}.sum_int(key int, val int)
                             RETURNS NULL ON NULL INPUT
                             RETURNS int
-                            LANGUAGE javascript AS 'key + val';""".format(self.keyspace_name))
+                            LANGUAGE java AS ' return key + val;';""".format(self.keyspace_name))
 
         self.assertEqual(cluster2.metadata.keyspaces[self.keyspace_name].functions, {})
         cluster2.refresh_user_function_metadata(self.keyspace_name, UserFunctionDescriptor("sum_int", ["int", "int"]))
@@ -873,7 +884,7 @@ def test_refresh_user_aggregate_metadata(self):
         self.session.execute("""CREATE FUNCTION {0}.sum_int(key int, val int)
                             RETURNS NULL ON NULL INPUT
                             RETURNS int
-                            LANGUAGE javascript AS 'key + val';""".format(self.keyspace_name))
+                            LANGUAGE java AS 'return key + val;';""".format(self.keyspace_name))
 
         self.session.execute("""CREATE AGGREGATE {0}.sum_agg(int)
                              SFUNC sum_int
@@ -956,7 +967,8 @@ class Ext1(Ext0):
         self.assertFalse(view_meta.extensions)
         self.assertIn(Ext0.name, _RegisteredExtensionType._extension_registry)
         self.assertIn(Ext1.name, _RegisteredExtensionType._extension_registry)
-        self.assertEqual(len(_RegisteredExtensionType._extension_registry), 2)
+        # There will bee the RLAC extension here.
+        self.assertEqual(len(_RegisteredExtensionType._extension_registry), 3)
 
         self.cluster.refresh_table_metadata(ks, t)
         table_meta = ks_meta.tables[t]
@@ -1481,7 +1493,10 @@ def make_function_kwargs(self, called_on_null=True):
                 'return_type': 'double',
                 'language': 'java',
                 'body': 'return new Double(0.0);',
-                'called_on_null_input': called_on_null}
+                'called_on_null_input': called_on_null,
+                'deterministic': False,
+                'monotonic': False,
+                'monotonic_on': []}
 
     def test_functions_after_udt(self):
         """
@@ -1632,15 +1647,15 @@ def setup_class(cls):
             cls.session.execute("""CREATE OR REPLACE FUNCTION sum_int(s int, i int)
                                    RETURNS NULL ON NULL INPUT
                                    RETURNS int
-                                   LANGUAGE javascript AS 's + i';""")
+                                   LANGUAGE java AS 'return s + i;';""")
             cls.session.execute("""CREATE OR REPLACE FUNCTION sum_int_two(s int, i int, j int)
                                    RETURNS NULL ON NULL INPUT
                                    RETURNS int
-                                   LANGUAGE javascript AS 's + i + j';""")
+                                   LANGUAGE java AS 'return s + i + j;';""")
             cls.session.execute("""CREATE OR REPLACE FUNCTION "List_As_String"(l list<text>)
                                    RETURNS NULL ON NULL INPUT
                                    RETURNS int
-                                   LANGUAGE javascript AS ''''' + l';""")
+                                   LANGUAGE java AS 'return l.size();';""")
             cls.session.execute("""CREATE OR REPLACE FUNCTION extend_list(s list<text>, i int)
                                    CALLED ON NULL INPUT
                                    RETURNS list<text>
@@ -1663,7 +1678,8 @@ def make_aggregate_kwargs(self, state_func, state_type, final_func=None, init_co
                 'state_type': state_type,
                 'final_func': final_func,
                 'initial_condition': init_cond,
-                'return_type': "does not matter for creation"}
+                'return_type': "does not matter for creation",
+                'deterministic': False}
 
     def test_return_type_meta(self):
         """
@@ -1887,7 +1903,13 @@ def setup_class(cls):
         cls.session.execute("CREATE KEYSPACE %s WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1}" % cls.keyspace_name)
         cls.session.set_keyspace(cls.keyspace_name)
         connection = cls.cluster.control_connection._connection
-        cls.parser_class = get_schema_parser(connection, CASSANDRA_VERSION.base_version, timeout=20).__class__
+
+        cls.parser_class = get_schema_parser(
+            connection,
+            cls.cluster.metadata.get_host(connection.host).release_version,
+            cls.cluster.metadata.get_host(connection.host).dse_version,
+            timeout=20
+        ).__class__
         cls.cluster.control_connection.reconnect = Mock()
 
     @classmethod
@@ -1932,28 +1954,36 @@ def test_bad_user_function(self):
         self.session.execute("""CREATE FUNCTION IF NOT EXISTS %s (key int, val int)
                                 RETURNS NULL ON NULL INPUT
                                 RETURNS int
-                                LANGUAGE javascript AS 'key + val';""" % self.function_name)
-        with patch.object(self.parser_class, '_build_function', side_effect=self.BadMetaException):
-            self.cluster.refresh_schema_metadata()   # presently do not capture these errors on udt direct refresh -- make sure it's contained during full refresh
-            m = self.cluster.metadata.keyspaces[self.keyspace_name]
-            self.assertIs(m._exc_info[0], self.BadMetaException)
-            self.assertIn("/*\nWarning:", m.export_as_string())
+                                LANGUAGE java AS 'return key + val;';""" % self.function_name)
+
+        #We need to patch as well the reconnect function because after patching the _build_function
+        #there will an Error refreshing schema which will trigger a reconnection. If this happened
+        #in a timely manner in the call self.cluster.refresh_schema_metadata() it would return an exception
+        #due to that a connection would be closed
+        with patch.object(self.cluster.control_connection, 'reconnect'):
+            with patch.object(self.parser_class, '_build_function', side_effect=self.BadMetaException):
+                self.cluster.refresh_schema_metadata()   # presently do not capture these errors on udt direct refresh -- make sure it's contained during full refresh
+                m = self.cluster.metadata.keyspaces[self.keyspace_name]
+                self.assertIs(m._exc_info[0], self.BadMetaException)
+                self.assertIn("/*\nWarning:", m.export_as_string())
 
     @greaterthancass21
     def test_bad_user_aggregate(self):
         self.session.execute("""CREATE FUNCTION IF NOT EXISTS sum_int (key int, val int)
                                 RETURNS NULL ON NULL INPUT
                                 RETURNS int
-                                LANGUAGE javascript AS 'key + val';""")
+                                LANGUAGE java AS 'return key + val;';""")
         self.session.execute("""CREATE AGGREGATE %s(int)
                                  SFUNC sum_int
                                  STYPE int
                                  INITCOND 0""" % self.function_name)
-        with patch.object(self.parser_class, '_build_aggregate', side_effect=self.BadMetaException):
-            self.cluster.refresh_schema_metadata()   # presently do not capture these errors on udt direct refresh -- make sure it's contained during full refresh
-            m = self.cluster.metadata.keyspaces[self.keyspace_name]
-            self.assertIs(m._exc_info[0], self.BadMetaException)
-            self.assertIn("/*\nWarning:", m.export_as_string())
+        #We have the same issue here as in test_bad_user_function
+        with patch.object(self.cluster.control_connection, 'reconnect'):
+            with patch.object(self.parser_class, '_build_aggregate', side_effect=self.BadMetaException):
+                self.cluster.refresh_schema_metadata()   # presently do not capture these errors on udt direct refresh -- make sure it's contained during full refresh
+                m = self.cluster.metadata.keyspaces[self.keyspace_name]
+                self.assertIs(m._exc_info[0], self.BadMetaException)
+                self.assertIn("/*\nWarning:", m.export_as_string())
 
 
 class DynamicCompositeTypeTest(BasicSharedKeyspaceUnitTestCase):
@@ -2244,6 +2274,8 @@ def test_base_table_type_alter_mv(self):
         test_create_view_metadata tests that materialized views metadata is properly updated when the type of base table
         column is changed.
 
+        Support for alter type was removed in CASSANDRA-12443
+
         @since 3.0.0
         @jira_ticket CASSANDRA-10424
         @expected_result Materialized view metadata should be updated correctly
@@ -2363,6 +2395,21 @@ def test_metadata_with_quoted_identifiers(self):
         self.assertIsNotNone(value_column)
         self.assertEqual(value_column.name, 'the Value')
 
+    @greaterthanorequaldse51
+    def test_dse_workloads(self):
+        """
+        Test to ensure dse_workloads is populated appropriately.
+        Field added in DSE 5.1
+
+        @jira_ticket PYTHON-667
+        @expected_result dse_workloads set is set on host model
+
+        @test_category metadata
+        """
+        for host in self.cluster.metadata.all_hosts():
+            self.assertIsInstance(host.dse_workloads, SortedSet)
+            self.assertIn("Cassandra", host.dse_workloads)
+
 
 class GroupPerHost(BasicSharedKeyspaceUnitTestCase):
     @classmethod
@@ -2416,30 +2463,18 @@ class VirtualKeypaceTest(BasicSharedKeyspaceUnitTestCase):
     virtual_ks_names = ('system_virtual_schema', 'system_views')
 
     virtual_ks_structure = {
-        'system_views': {
-            # map from table names to sets of column names for unordered
-            # comparison
-            'caches': {'capacity_bytes', 'entry_count', 'hit_count',
-                       'hit_ratio', 'name', 'recent_hit_rate_per_second',
-                       'recent_request_rate_per_second', 'request_count',
-                       'size_bytes'},
-            'clients': {'address', 'connection_stage', 'driver_name',
-                        'driver_version', 'hostname', 'port',
-                        'protocol_version', 'request_count',
-                        'ssl_cipher_suite', 'ssl_enabled', 'ssl_protocol',
-                        'username'},
-            'sstable_tasks': {'keyspace_name', 'kind', 'progress',
-                              'table_name', 'task_id', 'total', 'unit'},
-            'thread_pools': {'active_tasks', 'active_tasks_limit',
-                             'blocked_tasks', 'blocked_tasks_all_time',
-                             'completed_tasks', 'name', 'pending_tasks'}
-        },
+        # keyspaces
         'system_virtual_schema': {
-            'columns': {'clustering_order', 'column_name',
-                        'column_name_bytes', 'keyspace_name', 'kind',
-                        'position', 'table_name', 'type'},
+            # tables: columns. columns are a set because we're comparing unordered
             'keyspaces': {'keyspace_name'},
-            'tables': {'comment', 'keyspace_name', 'table_name'}
+            'tables': {'comment', 'keyspace_name', 'table_name'},
+            'columns': {'clustering_order', 'column_name', 'column_name_bytes',
+                        'keyspace_name', 'kind', 'position', 'table_name',
+                        'type'}
+        },
+        'system_views': {
+            'sstable_tasks': {'keyspace_name', 'kind', 'progress',
+                              'table_name', 'task_id', 'total', 'unit'}
         }
     }
 
@@ -2457,6 +2492,7 @@ def test_existing_keyspaces_have_correct_virtual_tags(self):
                 )
 
     @greaterthanorequalcass40
+    @greaterthanorequaldse67
     def test_expected_keyspaces_exist_and_are_virtual(self):
         for name in self.virtual_ks_names:
             self.assertTrue(
@@ -2465,6 +2501,7 @@ def test_expected_keyspaces_exist_and_are_virtual(self):
             )
 
     @greaterthanorequalcass40
+    @greaterthanorequaldse67
     def test_virtual_keyspaces_have_expected_schema_structure(self):
         self.maxDiff = None