matrixone-python-sdk 0.1.0__py3-none-any.whl

tests/online/test_config.py

@@ -0,0 +1,90 @@
+# Copyright 2021 - 2022 Matrix Origin
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Configuration for online tests
+"""
+
+import os
+from typing import Optional, Tuple
+
+
+class OnlineTestConfig:
+    """Configuration for online tests"""
+
+    def __init__(self):
+        # Connection parameters
+        self.host = os.getenv('MATRIXONE_HOST', '127.0.0.1')
+        self.port = int(os.getenv('MATRIXONE_PORT', '6001'))
+        self.user = os.getenv('MATRIXONE_USER', 'root')
+        self.password = os.getenv('MATRIXONE_PASSWORD', '111')
+        self.database = os.getenv('MATRIXONE_DATABASE', 'test')
+
+        # Test database names (can be overridden for different test environments)
+        self.test_database = os.getenv('MATRIXONE_TEST_DATABASE', self.database)
+        self.sys_database = os.getenv('MATRIXONE_SYS_DATABASE', 'sys')
+
+        # Test account (for multi-tenant scenarios)
+        self.test_account = os.getenv('MATRIXONE_TEST_ACCOUNT', 'sys')
+
+        # Test table prefixes (to avoid conflicts)
+        self.table_prefix = os.getenv('MATRIXONE_TABLE_PREFIX', 'test_')
+
+        # Snapshot and backup settings
+        self.snapshot_prefix = os.getenv('MATRIXONE_SNAPSHOT_PREFIX', 'testsnapshot')
+
+        # Vector test settings
+        self.vector_dimensions = int(os.getenv('MATRIXONE_VECTOR_DIMENSIONS', '64'))
+        self.vector_test_data_size = int(os.getenv('MATRIXONE_VECTOR_TEST_SIZE', '100'))
+
+    def get_connection_params(self) -> Tuple[str, int, str, str, str]:
+        """Get connection parameters as tuple"""
+        return self.host, self.port, self.user, self.password, self.database
+
+    def get_test_database(self) -> str:
+        """Get test database name"""
+        return self.test_database
+
+    def get_sys_database(self) -> str:
+        """Get system database name"""
+        return self.sys_database
+
+    def get_test_account(self) -> str:
+        """Get test account name"""
+        return self.test_account
+
+    def get_table_name(self, base_name: str) -> str:
+        """Get full table name with prefix"""
+        return f"{self.table_prefix}{base_name}"
+
+    def get_snapshot_name(self, base_name: str = None) -> str:
+        """Get snapshot name with prefix"""
+        if base_name:
+            return f"{self.snapshot_prefix}_{base_name}"
+        return self.snapshot_prefix
+
+    def get_vector_dimensions(self) -> int:
+        """Get vector dimensions for tests"""
+        return self.vector_dimensions
+
+    def get_vector_test_data_size(self) -> int:
+        """Get vector test data size"""
+        return self.vector_test_data_size
+
+    def __str__(self):
+        return f"OnlineTestConfig(host={self.host}, port={self.port}, user={self.user}, database={self.database}, test_database={self.test_database})"
+
+
+# Global configuration instance
+online_config = OnlineTestConfig()

tests/online/test_config_validation.py

@@ -0,0 +1,123 @@
+# Copyright 2021 - 2022 Matrix Origin
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Test configuration validation for online tests
+"""
+
+import pytest
+import os
+from .test_config import online_config
+
+
+class TestConfigValidation:
+    """Test that the configuration system works correctly"""
+
+    def test_config_has_all_required_attributes(self):
+        """Test that config has all required attributes"""
+        assert hasattr(online_config, 'host')
+        assert hasattr(online_config, 'port')
+        assert hasattr(online_config, 'user')
+        assert hasattr(online_config, 'password')
+        assert hasattr(online_config, 'database')
+        assert hasattr(online_config, 'test_database')
+        assert hasattr(online_config, 'sys_database')
+        assert hasattr(online_config, 'test_account')
+        assert hasattr(online_config, 'table_prefix')
+        assert hasattr(online_config, 'snapshot_prefix')
+        assert hasattr(online_config, 'vector_dimensions')
+        assert hasattr(online_config, 'vector_test_data_size')
+
+    def test_config_methods_work(self):
+        """Test that config methods work correctly"""
+        # Test connection params
+        host, port, user, password, database = online_config.get_connection_params()
+        assert isinstance(host, str)
+        assert isinstance(port, int)
+        assert isinstance(user, str)
+        assert isinstance(password, str)
+        assert isinstance(database, str)
+
+        # Test database names
+        test_db = online_config.get_test_database()
+        sys_db = online_config.get_sys_database()
+        assert isinstance(test_db, str)
+        assert isinstance(sys_db, str)
+
+        # Test account
+        account = online_config.get_test_account()
+        assert isinstance(account, str)
+
+        # Test table name generation
+        table_name = online_config.get_table_name("test_table")
+        assert table_name == f"{online_config.table_prefix}test_table"
+
+        # Test snapshot name generation
+        snapshot_name = online_config.get_snapshot_name("test_snapshot")
+        assert snapshot_name == f"{online_config.snapshot_prefix}_test_snapshot"
+
+        # Test vector settings
+        dimensions = online_config.get_vector_dimensions()
+        data_size = online_config.get_vector_test_data_size()
+        assert isinstance(dimensions, int)
+        assert isinstance(data_size, int)
+
+    def test_config_respects_environment_variables(self):
+        """Test that config respects environment variables"""
+        # Save original values
+        original_host = online_config.host
+        original_port = online_config.port
+        original_user = online_config.user
+        original_password = online_config.password
+        original_database = online_config.database
+
+        try:
+            # Set test environment variables
+            os.environ['MATRIXONE_HOST'] = 'test_host'
+            os.environ['MATRIXONE_PORT'] = '9999'
+            os.environ['MATRIXONE_USER'] = 'test_user'
+            os.environ['MATRIXONE_PASSWORD'] = 'test_password'
+            os.environ['MATRIXONE_DATABASE'] = 'test_db'
+
+            # Create new config instance to test env vars
+            from .test_config import OnlineTestConfig
+
+            test_config = OnlineTestConfig()
+
+            assert test_config.host == 'test_host'
+            assert test_config.port == 9999
+            assert test_config.user == 'test_user'
+            assert test_config.password == 'test_password'
+            assert test_config.database == 'test_db'
+
+        finally:
+            # Clean up environment variables
+            for key in [
+                'MATRIXONE_HOST',
+                'MATRIXONE_PORT',
+                'MATRIXONE_USER',
+                'MATRIXONE_PASSWORD',
+                'MATRIXONE_DATABASE',
+            ]:
+                if key in os.environ:
+                    del os.environ[key]
+
+    def test_config_string_representation(self):
+        """Test config string representation"""
+        config_str = str(online_config)
+        assert 'OnlineTestConfig' in config_str
+        assert online_config.host in config_str
+        assert str(online_config.port) in config_str
+        assert online_config.user in config_str
+        assert online_config.database in config_str

tests/online/test_connection_hooks_new_online.py

@@ -0,0 +1,217 @@
+# Copyright 2021 - 2022 Matrix Origin
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#!/usr/bin/env python3
+"""
+Online tests for the new connection hooks functionality using SQLAlchemy events
+"""
+
+import pytest
+from matrixone import Client, AsyncClient
+from matrixone.connection_hooks import ConnectionAction, create_connection_hook
+
+
+class TestNewConnectionHooksOnline:
+    """Test the new connection hooks implementation with SQLAlchemy events"""
+
+    def test_sync_client_connection_hook_executes_on_each_connection(self, test_client):
+        """Test that connection hook executes on each new connection"""
+        # Create a new client instance
+        client = Client()
+
+        # Track how many times the hook is called
+        hook_call_count = 0
+
+        def count_hook_calls(client):
+            nonlocal hook_call_count
+            hook_call_count += 1
+            print(f"Hook called {hook_call_count} times")
+
+        # Connect with the hook
+        client.connect(
+            host=test_client._connection_params['host'],
+            port=test_client._connection_params['port'],
+            user=test_client._connection_params['user'],
+            password=test_client._connection_params['password'],
+            database=test_client._connection_params['database'],
+            on_connect=count_hook_calls,
+        )
+
+        # The hook should be called once for the initial connection
+        assert hook_call_count >= 1
+
+        # Force a new connection by executing a query
+        # This should trigger the hook again
+        result = client.execute("SELECT 1")
+        assert len(result.rows) == 1
+
+        # The hook should be called again for the new connection
+        assert hook_call_count >= 2
+
+        # Clean up
+        client.disconnect()
+
+    def test_sync_client_with_predefined_actions(self, test_client):
+        """Test sync client with predefined actions"""
+        client = Client()
+
+        # Connect with predefined actions
+        client.connect(
+            host=test_client._connection_params['host'],
+            port=test_client._connection_params['port'],
+            user=test_client._connection_params['user'],
+            password=test_client._connection_params['password'],
+            database=test_client._connection_params['database'],
+            on_connect=[ConnectionAction.ENABLE_FULLTEXT],
+        )
+
+        assert client.connected()
+
+        # Test that we can use fulltext operations
+        # (This would fail if fulltext wasn't enabled)
+        try:
+            # Create a simple table and test fulltext
+            client.execute("CREATE TABLE IF NOT EXISTS test_hook_table (id INT, content TEXT)")
+            client.execute("INSERT INTO test_hook_table VALUES (1, 'test content')")
+
+            # This should work if fulltext is enabled
+            result = (
+                client.query("test_hook_table.content")
+                .filter("MATCH(content) AGAINST('test' IN NATURAL LANGUAGE MODE)")
+                .execute()
+            )
+
+            # Clean up
+            client.execute("DROP TABLE IF EXISTS test_hook_table")
+
+        except Exception as e:
+            # If fulltext is not available, that's okay for this test
+            print(f"Fulltext test skipped: {e}")
+
+        # Clean up
+        client.disconnect()
+
+    @pytest.mark.asyncio
+    async def test_async_client_connection_hook_executes_on_each_connection(self, test_async_client):
+        """Test that async connection hook executes on each new connection"""
+        # Create a new client instance
+        client = AsyncClient()
+
+        # Track how many times the hook is called
+        hook_call_count = 0
+
+        def count_hook_calls(client):
+            nonlocal hook_call_count
+            hook_call_count += 1
+            print(f"Async hook called {hook_call_count} times")
+
+        # Connect with the hook
+        await client.connect(
+            host=test_async_client._connection_params['host'],
+            port=test_async_client._connection_params['port'],
+            user=test_async_client._connection_params['user'],
+            password=test_async_client._connection_params['password'],
+            database=test_async_client._connection_params['database'],
+            on_connect=count_hook_calls,
+        )
+
+        # The hook should be called once for the initial connection
+        assert hook_call_count >= 1
+
+        # Force a new connection by executing a query
+        # This should trigger the hook again
+        result = await client.execute("SELECT 1")
+        assert len(result.rows) == 1
+
+        # The hook should be called again for the new connection
+        assert hook_call_count >= 2
+
+        # Clean up
+        await client.disconnect()
+
+    @pytest.mark.asyncio
+    async def test_async_client_with_predefined_actions(self, test_async_client):
+        """Test async client with predefined actions"""
+        client = AsyncClient()
+
+        # Connect with predefined actions
+        await client.connect(
+            host=test_async_client._connection_params['host'],
+            port=test_async_client._connection_params['port'],
+            user=test_async_client._connection_params['user'],
+            password=test_async_client._connection_params['password'],
+            database=test_async_client._connection_params['database'],
+            on_connect=[ConnectionAction.ENABLE_FULLTEXT],
+        )
+
+        assert client.connected()
+
+        # Test that we can use fulltext operations
+        try:
+            # Create a simple table and test fulltext
+            await client.execute("CREATE TABLE IF NOT EXISTS test_async_hook_table (id INT, content TEXT)")
+            await client.execute("INSERT INTO test_async_hook_table VALUES (1, 'test content')")
+
+            # This should work if fulltext is enabled
+            result = (
+                await client.query("test_async_hook_table.content")
+                .filter("MATCH(content) AGAINST('test' IN NATURAL LANGUAGE MODE)")
+                .execute()
+            )
+
+            # Clean up
+            await client.execute("DROP TABLE IF EXISTS test_async_hook_table")
+
+        except Exception as e:
+            # If fulltext is not available, that's okay for this test
+            print(f"Async fulltext test skipped: {e}")
+
+        # Clean up
+        await client.disconnect()
+
+    def test_connection_hook_with_multiple_actions(self, test_client):
+        """Test connection hook with multiple actions"""
+        client = Client()
+
+        # Track which actions were executed
+        executed_actions = []
+
+        def track_actions(client):
+            executed_actions.append("custom_hook")
+
+        # Create hook with multiple actions
+        hook = create_connection_hook(
+            actions=[ConnectionAction.ENABLE_FULLTEXT, ConnectionAction.ENABLE_IVF], custom_hook=track_actions
+        )
+
+        # Connect with the hook
+        client.connect(
+            host=test_client._connection_params['host'],
+            port=test_client._connection_params['port'],
+            user=test_client._connection_params['user'],
+            password=test_client._connection_params['password'],
+            database=test_client._connection_params['database'],
+            on_connect=hook,
+        )
+
+        assert client.connected()
+
+        # Force a new connection to trigger the hook
+        client.execute("SELECT 1")
+
+        # The custom hook should have been called
+        assert "custom_hook" in executed_actions
+
+        # Clean up
+        client.disconnect()