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

tests/offline/test_vector_type.py

@@ -0,0 +1,174 @@
+# 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.
+
+"""
+Offline tests for VectorType SQLAlchemy integration.
+"""
+
+import pytest
+import sys
+from unittest.mock import Mock
+from matrixone.sqlalchemy_ext import VectorType, Vectorf32, Vectorf64, VectorTypeDecorator
+
+pytestmark = pytest.mark.vector
+
+# No longer needed - global mocks have been fixed
+
+
+class TestVectorType:
+    """Test VectorType functionality."""
+
+    def test_vector_type_creation(self):
+        """Test VectorType creation with different parameters."""
+        # Test with dimension
+        vec_type = VectorType(dimension=128, precision="f32")
+        assert vec_type.dimension == 128
+        assert vec_type.precision == "f32"
+
+        # Test without dimension
+        vec_type_no_dim = VectorType(precision="f64")
+        assert vec_type_no_dim.dimension is None
+        assert vec_type_no_dim.precision == "f64"
+
+    def test_vector_type_column_spec(self):
+        """Test VectorType column specification."""
+        # Test with dimension
+        vec_type = VectorType(dimension=64, precision="f32")
+        spec = vec_type.get_col_spec()
+        assert spec == "vecf32(64)"
+
+        # Test without dimension
+        vec_type_no_dim = VectorType(precision="f64")
+        spec = vec_type_no_dim.get_col_spec()
+        assert spec == "vecf64"
+
+    def test_vector_type_bind_processor(self):
+        """Test VectorType bind processor."""
+        vec_type = VectorType(dimension=3, precision="f32")
+        processor = vec_type.bind_processor(None)
+
+        # Test with list
+        result = processor([1.0, 2.0, 3.0])
+        assert result == "[1.0,2.0,3.0]"
+
+        # Test with string
+        result = processor("[1.0,2.0,3.0]")
+        assert result == "[1.0,2.0,3.0]"
+
+        # Test with None
+        result = processor(None)
+        assert result is None
+
+    def test_vector_type_result_processor(self):
+        """Test VectorType result processor."""
+        vec_type = VectorType(dimension=3, precision="f32")
+        processor = vec_type.result_processor(None, None)
+
+        # Test with vector string
+        result = processor("[1.0,2.0,3.0]")
+        assert result == [1.0, 2.0, 3.0]
+
+        # Test with empty vector
+        result = processor("[]")
+        assert result == []
+
+        # Test with None
+        result = processor(None)
+        assert result is None
+
+    def test_vectorf32_convenience_class(self):
+        """Test Vectorf32 convenience class."""
+        vec32 = Vectorf32(dimension=64)
+        assert vec32.dimension == 64
+        assert vec32.precision == "f32"
+
+        spec = vec32.get_col_spec()
+        assert spec == "vecf32(64)"
+
+    def test_vectorf64_convenience_class(self):
+        """Test Vectorf64 convenience class."""
+        vec64 = Vectorf64(dimension=128)
+        assert vec64.dimension == 128
+        assert vec64.precision == "f64"
+
+        spec = vec64.get_col_spec()
+        assert spec == "vecf64(128)"
+
+    def test_vector_type_decorator(self):
+        """Test VectorTypeDecorator functionality."""
+        decorator = VectorTypeDecorator(dimension=256, precision="f32")
+        assert decorator.dimension == 256
+        assert decorator.precision == "f32"
+
+    def test_vector_type_decorator_bind_processing(self):
+        """Test VectorTypeDecorator bind parameter processing."""
+        decorator = VectorTypeDecorator(dimension=3, precision="f32")
+
+        # Test with list
+        result = decorator.process_bind_param([1.0, 2.0, 3.0], None)
+        assert result == "[1.0,2.0,3.0]"
+
+        # Test with string
+        result = decorator.process_bind_param("[1.0,2.0,3.0]", None)
+        assert result == "[1.0,2.0,3.0]"
+
+        # Test with None
+        result = decorator.process_bind_param(None, None)
+        assert result is None
+
+    def test_vector_type_decorator_result_processing(self):
+        """Test VectorTypeDecorator result processing."""
+        decorator = VectorTypeDecorator(dimension=3, precision="f32")
+
+        # Test with vector string
+        result = decorator.process_result_value("[1.0,2.0,3.0]", None)
+        assert result == [1.0, 2.0, 3.0]
+
+        # Test with empty vector
+        result = decorator.process_result_value("[]", None)
+        assert result == []
+
+        # Test with None
+        result = decorator.process_result_value(None, None)
+        assert result is None
+
+    def test_vector_type_repr(self):
+        """Test VectorType string representation."""
+        # Test with dimension
+        vec_type = VectorType(dimension=128, precision="f32")
+        repr_str = repr(vec_type)
+        assert "VectorType" in repr_str
+        assert "dimension=128" in repr_str
+        assert "precision='f32'" in repr_str
+
+        # Test without dimension
+        vec_type_no_dim = VectorType(precision="f64")
+        repr_str = repr(vec_type_no_dim)
+        assert "VectorType" in repr_str
+        assert "precision='f64'" in repr_str
+
+    def test_vector_type_decorator_repr(self):
+        """Test VectorTypeDecorator string representation."""
+        # Test with dimension
+        decorator = VectorTypeDecorator(dimension=256, precision="f32")
+        repr_str = repr(decorator)
+        assert "VectorTypeDecorator" in repr_str
+        assert "dimension=256" in repr_str
+        assert "precision='f32'" in repr_str
+
+        # Test without dimension
+        decorator_no_dim = VectorTypeDecorator(precision="f64")
+        repr_str = repr(decorator_no_dim)
+        assert "VectorTypeDecorator" in repr_str
+        assert "precision='f64'" in repr_str

tests/offline/test_version_core.py

@@ -0,0 +1,328 @@
+#!/usr/bin/env python3
+
+# 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.
+
+"""
+MatrixOne Python SDK - Version Management Core Tests
+
+Test suite for the version management framework core functionality
+(without external dependencies).
+"""
+
+import unittest
+import sys
+import os
+
+# Add the matrixone package to the path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'matrixone'))
+
+# Import only the version management module
+from matrixone.version import (
+    VersionManager,
+    VersionInfo,
+    FeatureRequirement,
+    VersionComparison,
+    requires_version,
+    VersionError,
+)
+
+
+class TestVersionParsing(unittest.TestCase):
+    """Test version parsing functionality"""
+
+    def setUp(self):
+        self.version_manager = VersionManager()
+
+    def test_valid_version_parsing(self):
+        """Test parsing valid version strings"""
+        test_cases = [
+            ("3.0.1", VersionInfo(3, 0, 1)),
+            ("1.0.0", VersionInfo(1, 0, 0)),
+            ("10.25.100", VersionInfo(10, 25, 100)),
+            ("0.0.1", VersionInfo(0, 0, 1)),
+        ]
+
+        for version_str, expected in test_cases:
+            with self.subTest(version=version_str):
+                result = self.version_manager.parse_version(version_str)
+                self.assertEqual(result.major, expected.major)
+                self.assertEqual(result.minor, expected.minor)
+                self.assertEqual(result.patch, expected.patch)
+
+    def test_invalid_version_parsing(self):
+        """Test parsing invalid version strings"""
+        invalid_versions = [
+            "3.0",  # Missing patch
+            "3.0.1.2",  # Too many components
+            "3.0.a",  # Non-numeric component
+            "3.0.1-beta",  # Pre-release suffix
+            "",  # Empty string
+            "invalid",  # Completely invalid
+        ]
+
+        for invalid_version in invalid_versions:
+            with self.subTest(version=invalid_version):
+                with self.assertRaises(ValueError):
+                    self.version_manager.parse_version(invalid_version)
+
+    def test_version_string_representation(self):
+        """Test version string representation"""
+        version = VersionInfo(3, 0, 1)
+        self.assertEqual(str(version), "3.0.1")
+
+
+class TestVersionComparison(unittest.TestCase):
+    """Test version comparison functionality"""
+
+    def setUp(self):
+        self.version_manager = VersionManager()
+
+    def test_version_comparisons(self):
+        """Test various version comparisons"""
+        test_cases = [
+            # (version1, version2, expected_result)
+            ("3.0.2", "3.0.1", VersionComparison.GREATER),
+            ("3.0.1", "3.0.2", VersionComparison.LESS),
+            ("3.0.1", "3.0.1", VersionComparison.EQUAL),
+            ("2.1.19", "3.0.9", VersionComparison.LESS),
+            ("3.0.9", "2.1.19", VersionComparison.GREATER),
+            ("1.0.0", "2.0.0", VersionComparison.LESS),
+            ("2.0.0", "1.9.9", VersionComparison.GREATER),
+        ]
+
+        for v1, v2, expected in test_cases:
+            with self.subTest(v1=v1, v2=v2):
+                result = self.version_manager.compare_versions(v1, v2)
+                self.assertEqual(result, expected)
+
+    def test_version_compatibility_checks(self):
+        """Test version compatibility checking"""
+        self.version_manager.set_backend_version("3.0.1")
+
+        # Test >= operator
+        self.assertTrue(self.version_manager.is_version_compatible("3.0.0", operator=">="))
+        self.assertTrue(self.version_manager.is_version_compatible("3.0.1", operator=">="))
+        self.assertFalse(self.version_manager.is_version_compatible("3.0.2", operator=">="))
+
+        # Test > operator
+        self.assertTrue(self.version_manager.is_version_compatible("3.0.0", operator=">"))
+        self.assertFalse(self.version_manager.is_version_compatible("3.0.1", operator=">"))
+        self.assertFalse(self.version_manager.is_version_compatible("3.0.2", operator=">"))
+
+        # Test <= operator
+        self.assertFalse(self.version_manager.is_version_compatible("3.0.0", operator="<="))
+        self.assertTrue(self.version_manager.is_version_compatible("3.0.1", operator="<="))
+        self.assertTrue(self.version_manager.is_version_compatible("3.0.2", operator="<="))
+
+        # Test < operator
+        self.assertFalse(self.version_manager.is_version_compatible("3.0.0", operator="<"))
+        self.assertFalse(self.version_manager.is_version_compatible("3.0.1", operator="<"))
+        self.assertTrue(self.version_manager.is_version_compatible("3.0.2", operator="<"))
+
+        # Test == operator
+        self.assertFalse(self.version_manager.is_version_compatible("3.0.0", operator="=="))
+        self.assertTrue(self.version_manager.is_version_compatible("3.0.1", operator="=="))
+        self.assertFalse(self.version_manager.is_version_compatible("3.0.2", operator="=="))
+
+        # Test != operator
+        self.assertTrue(self.version_manager.is_version_compatible("3.0.0", operator="!="))
+        self.assertFalse(self.version_manager.is_version_compatible("3.0.1", operator="!="))
+        self.assertTrue(self.version_manager.is_version_compatible("3.0.2", operator="!="))
+
+
+class TestFeatureRequirements(unittest.TestCase):
+    """Test feature requirement functionality"""
+
+    def setUp(self):
+        self.version_manager = VersionManager()
+
+    def test_feature_registration_and_availability(self):
+        """Test feature registration and availability checking"""
+        # Register a feature requirement
+        feature = FeatureRequirement(
+            feature_name="test_feature",
+            min_version=VersionInfo(3, 0, 0),
+            max_version=VersionInfo(3, 5, 0),
+            description="Test feature",
+            alternative="Use alternative_feature instead",
+        )
+        self.version_manager.register_feature_requirement(feature)
+
+        # Test with compatible version
+        self.version_manager.set_backend_version("3.1.0")
+        self.assertTrue(self.version_manager.is_feature_available("test_feature"))
+
+        # Test with version too low
+        self.version_manager.set_backend_version("2.9.0")
+        self.assertFalse(self.version_manager.is_feature_available("test_feature"))
+
+        # Test with version too high
+        self.version_manager.set_backend_version("3.6.0")
+        self.assertFalse(self.version_manager.is_feature_available("test_feature"))
+
+    def test_feature_info_retrieval(self):
+        """Test feature information retrieval"""
+        feature = FeatureRequirement(
+            feature_name="info_test",
+            min_version=VersionInfo(2, 0, 0),
+            description="Information test feature",
+            alternative="Alternative approach",
+        )
+        self.version_manager.register_feature_requirement(feature)
+
+        retrieved = self.version_manager.get_feature_info("info_test")
+        self.assertIsNotNone(retrieved)
+        self.assertEqual(retrieved.feature_name, "info_test")
+        self.assertEqual(retrieved.description, "Information test feature")
+        self.assertEqual(retrieved.alternative, "Alternative approach")
+
+        # Test non-existent feature
+        self.assertIsNone(self.version_manager.get_feature_info("non_existent"))
+
+    def test_version_hints(self):
+        """Test version hint generation"""
+        self.version_manager.register_feature_requirement(
+            FeatureRequirement(
+                feature_name="hint_test",
+                min_version=VersionInfo(3, 0, 0),
+                description="Hint test feature",
+                alternative="Use hint_alternative",
+            )
+        )
+
+        # Test with version too low
+        self.version_manager.set_backend_version("2.5.0")
+        hint = self.version_manager.get_version_hint("hint_test", "Test context")
+
+        self.assertIn("3.0.0", hint)
+        self.assertIn("2.5.0", hint)
+        self.assertIn("hint_alternative", hint)
+        self.assertIn("Test context", hint)
+
+
+class TestVersionDecorator(unittest.TestCase):
+    """Test version checking decorator"""
+
+    def test_successful_version_check(self):
+        """Test successful version check"""
+
+        class TestClass:
+            def __init__(self):
+                # Set global version manager
+                from matrixone.version import _version_manager
+
+                _version_manager.set_backend_version("3.0.0")
+
+            @requires_version(min_version="2.0.0", feature_name="test_feature", description="Test feature")
+            def test_method(self):
+                return "success"
+
+        obj = TestClass()
+        result = obj.test_method()
+        self.assertEqual(result, "success")
+
+    def test_failed_version_check(self):
+        """Test failed version check"""
+
+        class TestClass:
+            def __init__(self):
+                # Set global version manager
+                from matrixone.version import _version_manager
+
+                _version_manager.set_backend_version("1.0.0")
+
+            @requires_version(
+                min_version="2.0.0",
+                feature_name="test_feature",
+                description="Test feature",
+                alternative="Use alternative method",
+            )
+            def test_method(self):
+                return "success"
+
+        obj = TestClass()
+        with self.assertRaises(VersionError):
+            obj.test_method()
+
+    def test_version_range_check(self):
+        """Test version range checking"""
+
+        class TestClass:
+            def __init__(self, version):
+                # Set global version manager
+                from matrixone.version import _version_manager
+
+                _version_manager.set_backend_version(version)
+
+            @requires_version(
+                min_version="2.0.0",
+                max_version="2.9.9",
+                feature_name="legacy_feature",
+                description="Legacy feature",
+            )
+            def legacy_method(self):
+                return "legacy success"
+
+        # Test within range
+        obj = TestClass("2.5.0")
+        result = obj.legacy_method()
+        self.assertEqual(result, "legacy success")
+
+        # Test below range
+        obj = TestClass("1.9.0")
+        with self.assertRaises(VersionError):
+            obj.legacy_method()
+
+        # Test above range
+        obj = TestClass("3.0.0")
+        with self.assertRaises(VersionError):
+            obj.legacy_method()
+
+
+def run_tests():
+    """Run all tests"""
+    # Create test suite
+    test_suite = unittest.TestSuite()
+
+    # Add test classes
+    test_classes = [
+        TestVersionParsing,
+        TestVersionComparison,
+        TestFeatureRequirements,
+        TestVersionDecorator,
+    ]
+
+    for test_class in test_classes:
+        tests = unittest.TestLoader().loadTestsFromTestCase(test_class)
+        test_suite.addTests(tests)
+
+    # Run tests
+    runner = unittest.TextTestRunner(verbosity=2)
+    result = runner.run(test_suite)
+
+    return result.wasSuccessful()
+
+
+if __name__ == "__main__":
+    print("MatrixOne Python SDK - Version Management Core Test Suite")
+    print("=" * 60)
+
+    success = run_tests()
+
+    if success:
+        print("\n✓ All tests passed!")
+    else:
+        print("\n✗ Some tests failed!")
+        sys.exit(1)