Fix tests

tests/unit/test_base/test_cassandra_config.py

@@ -257,8 +257,8 @@ class TestGetCassandraConfigFromParams:
         assert username == 'new-user'
         assert password == 'new-pass'
     
-    def test_backward_compatibility_graph_params(self):
+    def test_no_backward_compatibility_graph_params(self):
-        """Test backward compatibility with old graph_* parameter names."""
+        """Test that old graph_* parameter names are no longer supported."""
         params = {
             'graph_host': 'old-host',
             'graph_username': 'old-user',
@@ -267,26 +267,27 @@ class TestGetCassandraConfigFromParams:
         
         hosts, username, password = get_cassandra_config_from_params(params)
         
-        assert hosts == ['old-host']
+        # Should use defaults since graph_* params are not recognized
-        assert username == 'old-user'
+        assert hosts == ['cassandra']  # Default
-        assert password == 'old-pass'
+        assert username is None
+        assert password is None
     
-    def test_old_cassandra_user_compatibility(self):
+    def test_no_old_cassandra_user_compatibility(self):
-        """Test backward compatibility with cassandra_user (vs cassandra_username)."""
+        """Test that cassandra_user is no longer supported (must be cassandra_username)."""
         params = {
             'cassandra_host': 'compat-host',
-            'cassandra_user': 'compat-user',  # Old name
+            'cassandra_user': 'compat-user',  # Old name - not supported
             'cassandra_password': 'compat-pass'
         }
         
         hosts, username, password = get_cassandra_config_from_params(params)
         
         assert hosts == ['compat-host']
-        assert username == 'compat-user'
+        assert username is None  # cassandra_user is not recognized
         assert password == 'compat-pass'
     
-    def test_parameter_precedence(self):
+    def test_only_new_parameters_work(self):
-        """Test that new parameter names take precedence over old ones."""
+        """Test that only new parameter names are recognized."""
         params = {
             'cassandra_host': 'new-host',
             'graph_host': 'old-host',
@@ -299,9 +300,9 @@ class TestGetCassandraConfigFromParams:
         
         hosts, username, password = get_cassandra_config_from_params(params)
         
-        assert hosts == ['new-host']  # New takes precedence
+        assert hosts == ['new-host']  # Only cassandra_* params work
-        assert username == 'new-user'  # New takes precedence
+        assert username == 'new-user'  # Only cassandra_* params work
-        assert password == 'new-pass'  # New takes precedence
+        assert password == 'new-pass'  # Only cassandra_* params work
     
     def test_empty_params_with_env_fallback(self):
         """Test that empty params falls back to environment variables."""

tests/unit/test_query/test_triples_cassandra_query.py

@@ -83,7 +83,7 @@ class TestCassandraQueryProcessor:
         processor = Processor(
             taskgroup=MagicMock(),
             id='test-cassandra-query',
-            graph_host='localhost'
+            cassandra_host='localhost'
         )
         
         # Create query request with all SPO values
@@ -122,9 +122,9 @@ class TestCassandraQueryProcessor:
         
         processor = Processor(taskgroup=taskgroup_mock)
         
-        assert processor.graph_host == ['cassandra']  # Updated default
+        assert processor.cassandra_host == ['cassandra']  # Updated default
-        assert processor.username is None
+        assert processor.cassandra_username is None
-        assert processor.password is None
+        assert processor.cassandra_password is None
         assert processor.table is None
 
     def test_processor_initialization_with_custom_params(self):
@@ -133,14 +133,14 @@ class TestCassandraQueryProcessor:
         
         processor = Processor(
             taskgroup=taskgroup_mock,
-            graph_host='cassandra.example.com',
+            cassandra_host='cassandra.example.com',
-            graph_username='queryuser',
+            cassandra_username='queryuser',
-            graph_password='querypass'
+            cassandra_password='querypass'
         )
         
-        assert processor.graph_host == ['cassandra.example.com']
+        assert processor.cassandra_host == ['cassandra.example.com']
-        assert processor.username == 'queryuser'
+        assert processor.cassandra_username == 'queryuser'
-        assert processor.password == 'querypass'
+        assert processor.cassandra_password == 'querypass'
         assert processor.table is None
 
     @pytest.mark.asyncio
@@ -387,8 +387,8 @@ class TestCassandraQueryProcessor:
         
         processor = Processor(
             taskgroup=MagicMock(),
-            graph_username='authuser',
+            cassandra_username='authuser',
-            graph_password='authpass'
+            cassandra_password='authpass'
         )
         
         query = TriplesQueryRequest(

tests/unit/test_storage/test_cassandra_config_integration.py

@@ -30,9 +30,9 @@ class TestTriplesWriterConfiguration:
         with patch.dict(os.environ, env_vars, clear=True):
             processor = TriplesWriter(taskgroup=MagicMock())
             
-            assert processor.graph_host == ['env-host1', 'env-host2']
+            assert processor.cassandra_host == ['env-host1', 'env-host2']
-            assert processor.username == 'env-user'
+            assert processor.cassandra_username == 'env-user'
-            assert processor.password == 'env-pass'
+            assert processor.cassandra_password == 'env-pass'
     
     @patch('trustgraph.direct.cassandra.TrustGraph')
     def test_parameter_override_environment(self, mock_trust_graph):
@@ -51,13 +51,13 @@ class TestTriplesWriterConfiguration:
                 cassandra_password='param-pass'
             )
             
-            assert processor.graph_host == ['param-host1', 'param-host2']
+            assert processor.cassandra_host == ['param-host1', 'param-host2']
-            assert processor.username == 'param-user'
+            assert processor.cassandra_username == 'param-user'
-            assert processor.password == 'param-pass'
+            assert processor.cassandra_password == 'param-pass'
     
     @patch('trustgraph.direct.cassandra.TrustGraph')
-    def test_backward_compatibility_graph_params(self, mock_trust_graph):
+    def test_no_backward_compatibility_graph_params(self, mock_trust_graph):
-        """Test backward compatibility with old graph_* parameter names."""
+        """Test that old graph_* parameter names are no longer supported."""
         processor = TriplesWriter(
             taskgroup=MagicMock(),
             graph_host='compat-host',
@@ -65,9 +65,10 @@ class TestTriplesWriterConfiguration:
             graph_password='compat-pass'
         )
         
-        assert processor.graph_host == ['compat-host']
+        # Should use defaults since graph_* params are not recognized
-        assert processor.username == 'compat-user'
+        assert processor.cassandra_host == ['cassandra']  # Default
-        assert processor.password == 'compat-pass'
+        assert processor.cassandra_username is None
+        assert processor.cassandra_password is None
     
     @patch('trustgraph.direct.cassandra.TrustGraph')
     def test_default_configuration(self, mock_trust_graph):
@@ -75,9 +76,9 @@ class TestTriplesWriterConfiguration:
         with patch.dict(os.environ, {}, clear=True):
             processor = TriplesWriter(taskgroup=MagicMock())
             
-            assert processor.graph_host == ['cassandra']
+            assert processor.cassandra_host == ['cassandra']
-            assert processor.username is None
+            assert processor.cassandra_username is None
-            assert processor.password is None
+            assert processor.cassandra_password is None
 
 
 class TestObjectsWriterConfiguration:
@@ -98,9 +99,9 @@ class TestObjectsWriterConfiguration:
         with patch.dict(os.environ, env_vars, clear=True):
             processor = ObjectsWriter(taskgroup=MagicMock())
             
-            assert processor.graph_host == ['obj-env-host1', 'obj-env-host2']
+            assert processor.cassandra_host == ['obj-env-host1', 'obj-env-host2']
-            assert processor.graph_username == 'obj-env-user'
+            assert processor.cassandra_username == 'obj-env-user'
-            assert processor.graph_password == 'obj-env-pass'
+            assert processor.cassandra_password == 'obj-env-pass'
     
     @patch('trustgraph.storage.objects.cassandra.write.Cluster')
     def test_cassandra_connection_with_hosts_list(self, mock_cluster):
@@ -174,24 +175,24 @@ class TestTriplesQueryConfiguration:
         with patch.dict(os.environ, env_vars, clear=True):
             processor = TriplesQuery(taskgroup=MagicMock())
             
-            assert processor.graph_host == ['query-env-host1', 'query-env-host2']
+            assert processor.cassandra_host == ['query-env-host1', 'query-env-host2']
-            assert processor.username == 'query-env-user'
+            assert processor.cassandra_username == 'query-env-user'
-            assert processor.password == 'query-env-pass'
+            assert processor.cassandra_password == 'query-env-pass'
     
     @patch('trustgraph.direct.cassandra.TrustGraph')
-    def test_mixed_old_new_parameters(self, mock_trust_graph):
+    def test_only_new_parameters_work(self, mock_trust_graph):
-        """Test mixing old and new parameter names (new should win)."""
+        """Test that only new parameters work."""
         processor = TriplesQuery(
             taskgroup=MagicMock(),
             cassandra_host='new-host',
-            graph_host='old-host',
+            graph_host='old-host',  # Should be ignored
             cassandra_username='new-user',
-            graph_username='old-user'
+            graph_username='old-user'  # Should be ignored
         )
         
-        # New parameters should take precedence
+        # Only new parameters should work
-        assert processor.graph_host == ['new-host']
+        assert processor.cassandra_host == ['new-host']
-        assert processor.username == 'new-user'
+        assert processor.cassandra_username == 'new-user'
 
 
 class TestKgStoreConfiguration:
@@ -396,9 +397,9 @@ class TestConfigurationPriorityIntegration:
                 # Password not provided - should fall back to env
             )
             
-            assert processor.graph_host == ['cli-host1', 'cli-host2']  # From CLI
+            assert processor.cassandra_host == ['cli-host1', 'cli-host2']  # From CLI
-            assert processor.username == 'cli-user'                   # From CLI
+            assert processor.cassandra_username == 'cli-user'              # From CLI
-            assert processor.password == 'env-pass'                   # From env
+            assert processor.cassandra_password == 'env-pass'              # From env
     
     @patch('trustgraph.storage.knowledge.store.KnowledgeTableStore')
     def test_kg_store_priority_chain(self, mock_table_store):

tests/unit/test_storage/test_triples_cassandra_storage.py

@@ -20,9 +20,9 @@ class TestCassandraStorageProcessor:
         with patch.dict('os.environ', {}, clear=True):
             processor = Processor(taskgroup=taskgroup_mock)
         
-        assert processor.graph_host == ['cassandra']  # Updated default
+        assert processor.cassandra_host == ['cassandra']  # Updated default
-        assert processor.username is None
+        assert processor.cassandra_username is None
-        assert processor.password is None
+        assert processor.cassandra_password is None
         assert processor.table is None
 
     def test_processor_initialization_with_custom_params(self):
@@ -37,9 +37,9 @@ class TestCassandraStorageProcessor:
             cassandra_password='testpass'
         )
         
-        assert processor.graph_host == ['cassandra.example.com']
+        assert processor.cassandra_host == ['cassandra.example.com']
-        assert processor.username == 'testuser'
+        assert processor.cassandra_username == 'testuser'
-        assert processor.password == 'testpass'
+        assert processor.cassandra_password == 'testpass'
         assert processor.table is None
 
     def test_processor_initialization_with_partial_auth(self):
@@ -51,11 +51,11 @@ class TestCassandraStorageProcessor:
             cassandra_username='testuser'
         )
         
-        assert processor.username == 'testuser'
+        assert processor.cassandra_username == 'testuser'
-        assert processor.password is None
+        assert processor.cassandra_password is None
     
-    def test_processor_initialization_backward_compatibility(self):
+    def test_processor_no_backward_compatibility(self):
-        """Test processor initialization with old graph_* parameters (backward compatibility)"""
+        """Test that old graph_* parameters are no longer supported"""
         taskgroup_mock = MagicMock()
         
         processor = Processor(
@@ -65,12 +65,13 @@ class TestCassandraStorageProcessor:
             graph_password='old-pass'
         )
         
-        assert processor.graph_host == ['old-host']
+        # Should use defaults since graph_* params are not recognized
-        assert processor.username == 'old-user'
+        assert processor.cassandra_host == ['cassandra']  # Default
-        assert processor.password == 'old-pass'
+        assert processor.cassandra_username is None
+        assert processor.cassandra_password is None
     
-    def test_processor_parameter_precedence(self):
+    def test_processor_only_new_parameters_work(self):
-        """Test that new cassandra_* parameters take precedence over old graph_* parameters"""
+        """Test that only new cassandra_* parameters work"""
         taskgroup_mock = MagicMock()
         
         processor = Processor(
@@ -81,8 +82,8 @@ class TestCassandraStorageProcessor:
             graph_username='old-user'  # Should be ignored
         )
         
-        assert processor.graph_host == ['new-host']  # New parameter wins
+        assert processor.cassandra_host == ['new-host']  # Only cassandra_* params work
-        assert processor.username == 'new-user'     # New parameter wins
+        assert processor.cassandra_username == 'new-user'  # Only cassandra_* params work
 
     @pytest.mark.asyncio
     @patch('trustgraph.storage.triples.cassandra.write.TrustGraph')