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

tests/online/test_pubsub_operations.py

@@ -0,0 +1,352 @@
+# 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.
+
+"""
+Online tests for PubSub operations
+
+These tests are inspired by example_08_pubsub_operations.py
+"""
+
+import pytest
+import time
+from datetime import datetime
+from matrixone import Client, AsyncClient
+from matrixone.logger import create_default_logger
+from .test_config import online_config
+
+
+@pytest.mark.online
+class TestPubSubOperations:
+    """Test PubSub operations functionality"""
+
+    def test_basic_pubsub_operations(self, test_client):
+        """Test basic PubSub operations within the same account"""
+        # Create test database and tables
+        test_client.execute("CREATE DATABASE IF NOT EXISTS pubsub_test")
+        test_client.execute("USE pubsub_test")
+
+        test_client.execute(
+            """
+            CREATE TABLE IF NOT EXISTS products (
+                id INT PRIMARY KEY AUTO_INCREMENT,
+                name VARCHAR(100) NOT NULL,
+                price DECIMAL(10,2),
+                category VARCHAR(50),
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """
+        )
+
+        test_client.execute(
+            """
+            CREATE TABLE IF NOT EXISTS orders (
+                id INT PRIMARY KEY AUTO_INCREMENT,
+                product_id INT,
+                quantity INT,
+                total_price DECIMAL(10,2),
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """
+        )
+
+        try:
+            # Test 1: Basic PubSub setup (as per examples)
+            # Insert sample data
+            products_data = [
+                ("Laptop", 999.99, "Electronics"),
+                ("Mouse", 29.99, "Electronics"),
+                ("Keyboard", 79.99, "Electronics"),
+                ("Monitor", 299.99, "Electronics"),
+            ]
+
+            for name, price, category in products_data:
+                test_client.execute(f"INSERT INTO products (name, price, category) VALUES ('{name}', {price}, '{category}')")
+
+            # Test 2: List publications (as per examples - should work even if empty)
+            publications = test_client.pubsub.list_publications()
+            assert isinstance(publications, list)
+
+            # Test 3: List subscriptions (as per examples - should work even if empty)
+            subscriptions = test_client.pubsub.list_subscriptions()
+            assert isinstance(subscriptions, list)
+
+            # Test 4: Data operations
+            test_client.execute("INSERT INTO orders (product_id, quantity, total_price) VALUES (1, 2, 199.98)")
+
+            # Verify data
+            result = test_client.execute("SELECT COUNT(*) FROM products")
+            assert result.rows[0][0] == 4
+
+            result = test_client.execute("SELECT COUNT(*) FROM orders")
+            assert result.rows[0][0] == 1
+
+        finally:
+            # Cleanup
+            try:
+                test_client.pubsub.drop_subscription("product_subscription")
+                test_client.pubsub.drop_publication("product_updates")
+            except Exception as e:
+                print(f"Warning: Failed to cleanup pubsub resources: {e}")
+                # Don't ignore - this could indicate resource leaks
+
+            test_client.execute("DROP DATABASE IF EXISTS pubsub_test")
+
+    def test_pubsub_with_multiple_tables(self, test_client):
+        """Test PubSub with multiple tables"""
+        # Create test database
+        test_client.execute("CREATE DATABASE IF NOT EXISTS pubsub_multi_test")
+        test_client.execute("USE pubsub_multi_test")
+
+        # Create multiple tables
+        test_client.execute(
+            """
+            CREATE TABLE IF NOT EXISTS users (
+                id INT PRIMARY KEY AUTO_INCREMENT,
+                username VARCHAR(50) NOT NULL,
+                email VARCHAR(100) NOT NULL,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """
+        )
+
+        test_client.execute(
+            """
+            CREATE TABLE IF NOT EXISTS posts (
+                id INT PRIMARY KEY AUTO_INCREMENT,
+                user_id INT,
+                title VARCHAR(200) NOT NULL,
+                content TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """
+        )
+
+        test_client.execute(
+            """
+            CREATE TABLE IF NOT EXISTS comments (
+                id INT PRIMARY KEY AUTO_INCREMENT,
+                post_id INT,
+                user_id INT,
+                content TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """
+        )
+
+        try:
+            # Test multi-table PubSub operations (as per examples)
+            # Insert sample data
+            test_client.execute("INSERT INTO users (username, email) VALUES ('testuser', 'test@example.com')")
+            test_client.execute("INSERT INTO posts (user_id, title, content) VALUES (1, 'Test Post', 'This is a test post')")
+            test_client.execute("INSERT INTO comments (post_id, user_id, content) VALUES (1, 1, 'This is a test comment')")
+
+            # Test list operations (as per examples - should work even if empty)
+            publications = test_client.pubsub.list_publications()
+            assert isinstance(publications, list)
+
+            subscriptions = test_client.pubsub.list_subscriptions()
+            assert isinstance(subscriptions, list)
+
+            # Verify data across all tables
+            result = test_client.execute("SELECT COUNT(*) FROM users")
+            assert result.rows[0][0] == 1
+
+            result = test_client.execute("SELECT COUNT(*) FROM posts")
+            assert result.rows[0][0] == 1
+
+            result = test_client.execute("SELECT COUNT(*) FROM comments")
+            assert result.rows[0][0] == 1
+
+        finally:
+            # Cleanup
+            try:
+                test_client.pubsub.drop_publication("multi_table_publication")
+            except Exception as e:
+                print(f"Warning: Failed to cleanup multi-table publication: {e}")
+
+            test_client.execute("DROP DATABASE IF EXISTS pubsub_multi_test")
+
+    def test_pubsub_error_handling(self, test_client):
+        """Test PubSub error handling"""
+        # Test creating publication with invalid parameters
+        try:
+            test_client.pubsub.create_database_publication(
+                name="",  # Empty name should fail
+                database="nonexistent_db",
+                account=online_config.get_test_account(),
+            )
+            assert False, "Should have failed with empty name"
+        except Exception:
+            pass  # Expected to fail
+
+        # Test creating subscription with invalid parameters
+        try:
+            test_client.pubsub.create_subscription(
+                name="",  # Empty name should fail
+                publication="nonexistent_publication",
+                account=online_config.get_test_account(),
+            )
+            assert False, "Should have failed with empty name"
+        except Exception:
+            pass  # Expected to fail
+
+        # Test dropping non-existent publication
+        try:
+            test_client.pubsub.drop_publication("nonexistent_publication")
+            assert False, "Should have failed with non-existent publication"
+        except Exception:
+            pass  # Expected to fail
+
+        # Test dropping non-existent subscription
+        try:
+            test_client.pubsub.drop_subscription("nonexistent_subscription")
+            assert False, "Should have failed with non-existent subscription"
+        except Exception:
+            pass  # Expected to fail
+
+    def test_pubsub_listing_operations(self, test_client):
+        """Test PubSub listing operations"""
+        # Create test database
+        test_client.execute("CREATE DATABASE IF NOT EXISTS pubsub_list_test")
+        test_client.execute("USE pubsub_list_test")
+
+        test_client.execute(
+            """
+            CREATE TABLE IF NOT EXISTS test_table (
+                id INT PRIMARY KEY AUTO_INCREMENT,
+                name VARCHAR(50) NOT NULL
+            )
+        """
+        )
+
+        try:
+            # Test listing operations (as per examples - should work even if empty)
+            # Test listing publications
+            publications = test_client.pubsub.list_publications()
+            assert isinstance(publications, list)
+
+            # Test listing subscriptions
+            subscriptions = test_client.pubsub.list_subscriptions()
+            assert isinstance(subscriptions, list)
+
+            # Insert test data
+            test_client.execute("INSERT INTO test_table (name) VALUES ('test_item')")
+
+            # Verify data
+            result = test_client.execute("SELECT COUNT(*) FROM test_table")
+            assert result.rows[0][0] == 1
+
+        finally:
+            # Cleanup
+            try:
+                test_client.pubsub.drop_subscription("list_test_subscription")
+                test_client.pubsub.drop_publication("list_test_publication")
+            except Exception as e:
+                print(f"Warning: Failed to cleanup list test resources: {e}")
+
+            test_client.execute("DROP DATABASE IF EXISTS pubsub_list_test")
+
+    @pytest.mark.asyncio
+    async def test_async_pubsub_operations(self, test_async_client):
+        """Test async PubSub operations"""
+        # Create test database
+        await test_async_client.execute("CREATE DATABASE IF NOT EXISTS async_pubsub_test")
+        await test_async_client.execute("USE async_pubsub_test")
+
+        await test_async_client.execute(
+            """
+            CREATE TABLE IF NOT EXISTS async_test_table (
+                id INT PRIMARY KEY AUTO_INCREMENT,
+                name VARCHAR(50) NOT NULL,
+                value INT
+            )
+        """
+        )
+
+        try:
+            # Test async PubSub operations (as per examples)
+            # Test list operations (should work even if empty)
+            publications = await test_async_client.pubsub.list_publications()
+            assert isinstance(publications, list)
+
+            subscriptions = await test_async_client.pubsub.list_subscriptions()
+            assert isinstance(subscriptions, list)
+
+            # Test async data operations
+            await test_async_client.execute("INSERT INTO async_test_table (name, value) VALUES ('async_test', 42)")
+
+            # Verify data
+            result = await test_async_client.execute("SELECT COUNT(*) FROM async_test_table")
+            assert result.rows[0][0] == 1
+
+        finally:
+            # Cleanup
+            try:
+                await test_async_client.pubsub.drop_subscription("async_test_subscription")
+                await test_async_client.pubsub.drop_publication("async_test_publication")
+            except Exception as e:
+                print(f"Warning: Failed to cleanup async pubsub resources: {e}")
+
+            await test_async_client.execute("DROP DATABASE IF EXISTS async_pubsub_test")
+
+    def test_pubsub_with_logging(self, connection_params):
+        """Test PubSub operations with custom logging"""
+        host, port, user, password, database = connection_params
+
+        # Create logger
+        logger = create_default_logger()
+
+        # Create client with logging
+        client = Client()
+        client.connect(host=host, port=port, user=user, password=password, database=database)
+
+        try:
+            # Create test database
+            client.execute("CREATE DATABASE IF NOT EXISTS pubsub_log_test")
+            client.execute("USE pubsub_log_test")
+
+            client.execute(
+                """
+                CREATE TABLE IF NOT EXISTS log_test_table (
+                    id INT PRIMARY KEY AUTO_INCREMENT,
+                    name VARCHAR(50) NOT NULL
+                )
+            """
+            )
+
+            # Test PubSub operations with logging (as per examples)
+            # Test list operations (should work even if empty)
+            publications = client.pubsub.list_publications()
+            assert isinstance(publications, list)
+
+            subscriptions = client.pubsub.list_subscriptions()
+            assert isinstance(subscriptions, list)
+
+            # Test data operations with logging
+            client.execute("INSERT INTO log_test_table (name) VALUES ('log_test')")
+
+            # Verify data
+            result = client.execute("SELECT COUNT(*) FROM log_test_table")
+            assert result.rows[0][0] == 1
+
+            # Cleanup
+            try:
+                client.pubsub.drop_publication("log_test_publication")
+            except Exception as e:
+                print(f"Warning: Failed to cleanup logging test publication: {e}")
+
+            client.execute("DROP DATABASE IF EXISTS pubsub_log_test")
+
+        finally:
+            client.disconnect()

tests/online/test_query_methods.py

@@ -0,0 +1,225 @@
+# 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 cases for SQLAlchemy-style query methods (all, one, first, scalar, one_or_none)
+"""
+
+import pytest
+from sqlalchemy import Column, Integer, String, create_engine
+from sqlalchemy.exc import NoResultFound, MultipleResultsFound
+
+from matrixone import Client
+from matrixone.orm import declarative_base
+from .test_config import online_config
+
+Base = declarative_base()
+
+
+class QueryTestUser(Base):
+    __tablename__ = 'test_query_users'
+    id = Column(Integer, primary_key=True)
+    name = Column(String(50))
+    age = Column(Integer)
+
+
+class TestQueryMethods:
+    """Test SQLAlchemy-style query methods"""
+
+    @pytest.fixture(autouse=True)
+    def setup_and_cleanup(self):
+        """Setup test data and cleanup after tests"""
+        # Setup
+        self.client = Client()
+        host, port, user, password, database = online_config.get_connection_params()
+        self.client.connect(host=host, port=port, user=user, password=password, database=database)
+
+        # Create table (with checkfirst to avoid errors if table exists)
+        try:
+            self.client.create_table(QueryTestUser)
+        except Exception:
+            # Table might already exist, try to drop and recreate
+            try:
+                self.client.drop_table(QueryTestUser)
+                self.client.create_table(QueryTestUser)
+            except Exception:
+                pass  # Continue with existing table
+
+        # Insert test data
+        users_data = [
+            {"id": 1, "name": "Alice", "age": 25},
+            {"id": 2, "name": "Bob", "age": 30},
+            {"id": 3, "name": "Charlie", "age": 35},
+        ]
+        for user_data in users_data:
+            self.client.insert(QueryTestUser.__tablename__, user_data)
+
+        yield
+
+        # Cleanup
+        try:
+            self.client.drop_table(QueryTestUser)
+        except:
+            pass
+        self.client.disconnect()
+
+    def test_all_method(self):
+        """Test all() method returns all results"""
+        results = self.client.query(QueryTestUser).all()
+        assert len(results) == 3
+        assert all(isinstance(user, QueryTestUser) for user in results)
+        assert results[0].name == 'Alice'
+        assert results[1].name == 'Bob'
+        assert results[2].name == 'Charlie'
+
+    def test_first_method(self):
+        """Test first() method returns first result or None"""
+        # Test with results
+        result = self.client.query(QueryTestUser).first()
+        assert isinstance(result, QueryTestUser)
+        assert result.name == 'Alice'
+
+        # Test with no results
+        result = self.client.query(QueryTestUser).filter(QueryTestUser.id == 999).first()
+        assert result is None
+
+    def test_one_method_success(self):
+        """Test one() method with exactly one result"""
+        result = self.client.query(QueryTestUser).filter(QueryTestUser.id == 1).one()
+        assert isinstance(result, QueryTestUser)
+        assert result.name == 'Alice'
+
+    def test_one_method_no_results(self):
+        """Test one() method with no results raises NoResultFound"""
+        with pytest.raises(NoResultFound):
+            self.client.query(QueryTestUser).filter(QueryTestUser.id == 999).one()
+
+    def test_one_method_multiple_results(self):
+        """Test one() method with multiple results raises MultipleResultsFound"""
+        with pytest.raises(MultipleResultsFound):
+            self.client.query(QueryTestUser).filter(QueryTestUser.age > 20).one()
+
+    def test_one_or_none_method_success(self):
+        """Test one_or_none() method with exactly one result"""
+        result = self.client.query(QueryTestUser).filter(QueryTestUser.id == 1).one_or_none()
+        assert isinstance(result, QueryTestUser)
+        assert result.name == 'Alice'
+
+    def test_one_or_none_method_no_results(self):
+        """Test one_or_none() method with no results returns None"""
+        result = self.client.query(QueryTestUser).filter(QueryTestUser.id == 999).one_or_none()
+        assert result is None
+
+    def test_one_or_none_method_multiple_results(self):
+        """Test one_or_none() method with multiple results raises MultipleResultsFound"""
+        with pytest.raises(MultipleResultsFound):
+            self.client.query(QueryTestUser).filter(QueryTestUser.age > 20).one_or_none()
+
+    def test_scalar_method_with_model(self):
+        """Test scalar() method returns first column value from model"""
+        # Test with primary key (first column)
+        result = self.client.query(QueryTestUser).filter(QueryTestUser.id == 1).scalar()
+        assert result == 1
+
+        # Test with no results
+        result = self.client.query(QueryTestUser).filter(QueryTestUser.id == 999).scalar()
+        assert result is None
+
+    def test_scalar_method_with_select_columns(self):
+        """Test scalar() method with custom select columns"""
+        # Select specific column
+        result = self.client.query(QueryTestUser).select(QueryTestUser.name).filter(QueryTestUser.id == 1).scalar()
+        assert result == 'Alice'
+
+        # Select count - use count() method directly, not with select
+        result = self.client.query(QueryTestUser).count()
+        assert result == 3
+
+    def test_scalar_method_with_aggregate(self):
+        """Test scalar() method with aggregate functions"""
+        from sqlalchemy import func
+
+        # Count all users
+        result = self.client.query(QueryTestUser).select(func.count(QueryTestUser.id)).scalar()
+        assert result == 3
+
+        # Average age
+        result = self.client.query(QueryTestUser).select(func.avg(QueryTestUser.age)).scalar()
+        assert result == 30.0  # (25 + 30 + 35) / 3
+
+    def test_methods_with_filters(self):
+        """Test query methods work with various filters"""
+        # Test with multiple filters - use AND to combine conditions
+        from sqlalchemy import and_
+
+        result = self.client.query(QueryTestUser).filter(and_(QueryTestUser.age > 25, QueryTestUser.name.like('B%'))).one()
+        assert result.name == 'Bob'
+        assert result.age == 30
+
+    def test_methods_with_ordering(self):
+        """Test query methods work with ordering"""
+        # Test first() with ordering
+        result = self.client.query(QueryTestUser).order_by(QueryTestUser.age.desc()).first()
+        assert result.name == 'Charlie'
+        assert result.age == 35
+
+        # Test scalar() with ordering
+        result = self.client.query(QueryTestUser).select(QueryTestUser.name).order_by(QueryTestUser.age.desc()).scalar()
+        assert result == 'Charlie'
+
+    def test_methods_with_limit(self):
+        """Test query methods work with limit"""
+        # Test all() with limit
+        results = self.client.query(QueryTestUser).limit(2).all()
+        assert len(results) == 2
+
+        # Test first() with limit (should still return only one)
+        result = self.client.query(QueryTestUser).limit(2).first()
+        assert isinstance(result, QueryTestUser)
+
+    def test_count_method(self):
+        """Test count() method"""
+        # Count all
+        count = self.client.query(QueryTestUser).count()
+        assert count == 3
+
+        # Count with filter
+        count = self.client.query(QueryTestUser).filter(QueryTestUser.age > 25).count()
+        assert count == 2
+
+    def test_methods_consistency(self):
+        """Test that methods are consistent with each other"""
+        # Test that first() and all()[0] return same result
+        first_result = self.client.query(QueryTestUser).order_by(QueryTestUser.id).first()
+        all_results = self.client.query(QueryTestUser).order_by(QueryTestUser.id).all()
+        assert first_result.id == all_results[0].id
+
+        # Test that one() and one_or_none() return same result when exactly one exists
+        one_result = self.client.query(QueryTestUser).filter(QueryTestUser.id == 1).one()
+        one_or_none_result = self.client.query(QueryTestUser).filter(QueryTestUser.id == 1).one_or_none()
+        assert one_result.id == one_or_none_result.id
+
+    def test_error_messages(self):
+        """Test that error messages are informative"""
+        # Test NoResultFound message
+        with pytest.raises(NoResultFound, match="No row was found for one\\(\\)"):
+            self.client.query(QueryTestUser).filter(QueryTestUser.id == 999).one()
+
+        # Test MultipleResultsFound message
+        with pytest.raises(MultipleResultsFound, match="Multiple rows were found for one_or_none\\(\\)"):
+            self.client.query(QueryTestUser).filter(QueryTestUser.age > 20).one_or_none()
+
+
+if __name__ == '__main__':
+    pytest.main([__file__])