added tests for Type_Safe__Fast_Create

Author: DinisCruz

osbot_utils/type_safe/type_safe_core/fast_create/Type_Safe__Fast_Create.py

@@ -17,8 +17,8 @@
 #
 # ═══════════════════════════════════════════════════════════════════════════════
 
-from typing                                  import Any
-from Type_Safe__Fast_Create__Cache           import type_safe_fast_create_cache
+from typing                                                                         import Any
+from osbot_utils.type_safe.type_safe_core.fast_create.Type_Safe__Fast_Create__Cache import type_safe_fast_create_cache
 
 
 # ═══════════════════════════════════════════════════════════════════════════════

osbot_utils/type_safe/type_safe_core/fast_create/Type_Safe__Fast_Create__Cache.py

@@ -32,13 +32,19 @@
 
 class Type_Safe__Fast_Create__Cache:                                              # Schema generation and caching
 
-    schema_cache : Dict[Type, Schema__Type_Safe__Fast_Create__Class]                                      # Class -> Schema mapping
+    schema_cache : Dict[Type, Schema__Type_Safe__Fast_Create__Class]              # Class -> Schema mapping
     generating   : Set[Type]                                                      # Guards against recursion
 
     def __init__(self):
         self.schema_cache = {}                                                    # Regular dict - classes persist
         self.generating   = set()                                                 # Recursion guard
 
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass
+
     # ═══════════════════════════════════════════════════════════════════════════
     # Public API
     # ═══════════════════════════════════════════════════════════════════════════

tests/unit/type_safe/type_safe_core/config/_performance/hypothesis/hypothesis_G__production_fast_create/test_Type_Safe__Hypothesis_G.py

@@ -1,14 +1,13 @@
 # ═══════════════════════════════════════════════════════════════════════════════
-# Tests: Type_Safe__Fast_Create__Cache - Schema Generation and Caching
-# Verify schema generation, field classification, and cache behavior
+# Tests: Type_Safe__Hypothesis_G - Functional Tests for Fast Object Creation
+# Verify fast_create produces correct, fully functional objects
 # ═══════════════════════════════════════════════════════════════════════════════
 
 from typing                                  import Dict, List
 from unittest                                import TestCase
+from Type_Safe__Config                       import Type_Safe__Config
 from Type_Safe__Hypothesis_G                 import Type_Safe__Hypothesis_G
 from Type_Safe__Fast_Create__Cache           import type_safe_fast_create_cache
-from schemas.Field__Schema                   import FIELD_MODE__STATIC
-from schemas.Field__Schema                   import FIELD_MODE__NESTED
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -52,135 +51,178 @@ class TS__Deep(Type_Safe__Hypothesis_G):
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
-# Immutability Tests
+# Normal Mode Tests (fast_create=False)
 # ═══════════════════════════════════════════════════════════════════════════════
 
-class test_is_immutable(TestCase):
+class test_normal_mode(TestCase):
 
-    def test__immutable_types(self):
-        cache = type_safe_fast_create_cache
+    def setUp(self):
+        type_safe_fast_create_cache.clear_cache()
+
+    def test__creates_object_with_defaults(self):
+        obj = TS__Simple()
+
+        assert type(obj) is TS__Simple
+        assert obj.name   == ''
+        assert obj.count  == 0
+        assert obj.active == False
+
+    def test__creates_object_with_kwargs(self):
+        obj = TS__Simple(name='test', count=42)
 
-        assert cache.is_immutable('')        is True
-        assert cache.is_immutable('hello')   is True
-        assert cache.is_immutable(0)         is True
-        assert cache.is_immutable(42)        is True
-        assert cache.is_immutable(3.14)      is True
-        assert cache.is_immutable(True)      is True
-        assert cache.is_immutable(False)     is True
-        assert cache.is_immutable(None)      is True
-        assert cache.is_immutable(b'bytes')  is True
-        assert cache.is_immutable((1, 2, 3)) is True
+        assert obj.name   == 'test'
+        assert obj.count  == 42
+        assert obj.active == False
 
-    def test__mutable_types(self):
-        cache = type_safe_fast_create_cache
+    def test__creates_nested_objects(self):
+        obj = TS__With_Nested()
 
-        assert cache.is_immutable([])        is False
-        assert cache.is_immutable({})        is False
-        assert cache.is_immutable(set())     is False
-        assert cache.is_immutable([1, 2, 3]) is False
+        assert obj.inner        is not None
+        assert type(obj.inner)  is TS__Inner
+        assert obj.inner.value  == ''
+        assert obj.inner.count  == 0
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
-# Schema Generation Tests
+# Fast Create Mode Tests (fast_create=True)
 # ═══════════════════════════════════════════════════════════════════════════════
 
-class test_generate_schema(TestCase):
+class test_fast_create_mode(TestCase):
 
     def setUp(self):
         type_safe_fast_create_cache.clear_cache()
 
-    def test__simple_class__all_static(self):
-        schema = type_safe_fast_create_cache.generate_schema(TS__Simple)
+    def test__creates_object_with_defaults(self):
+        with Type_Safe__Config(fast_create=True):
+            obj = TS__Simple()
+
+        assert type(obj) is TS__Simple
+        assert obj.name   == ''
+        assert obj.count  == 0
+        assert obj.active == False
+
+    def test__creates_object_with_kwargs(self):
+        with Type_Safe__Config(fast_create=True):
+            obj = TS__Simple(name='fast', count=99)
+
+        assert obj.name   == 'fast'
+        assert obj.count  == 99
+        assert obj.active == False
+
+    def test__collections_not_shared(self):
+        with Type_Safe__Config(fast_create=True):
+            obj1 = TS__With_Collections()
+            obj2 = TS__With_Collections()
 
-        assert schema.target_class is TS__Simple
-        assert len(schema.fields)  == 3
+        obj1.items.append('item1')
 
-        for field in schema.fields:
-            assert field.mode == FIELD_MODE__STATIC
+        assert len(obj1.items) == 1
+        assert len(obj2.items) == 0                                               # Not shared!
 
-        assert schema.static_dict['name']   == ''
-        assert schema.static_dict['count']  == 0
-        assert schema.static_dict['active'] == False
+    def test__nested_objects_created(self):
+        with Type_Safe__Config(fast_create=True):
+            obj = TS__With_Nested()
 
-    def test__class_with_collections__factory_fields(self):
-        schema = type_safe_fast_create_cache.generate_schema(TS__With_Collections)
+        assert obj.inner        is not None
+        assert type(obj.inner)  is TS__Inner
+        assert obj.inner.value  == ''
+        assert obj.inner.count  == 0
 
-        assert 'name' in schema.static_dict                                       # Static field
+    def test__nested_objects_not_shared(self):
+        with Type_Safe__Config(fast_create=True):
+            obj1 = TS__With_Nested()
+            obj2 = TS__With_Nested()
 
-        assert len(schema.factory_fields) == 2                                    # items and data
-        factory_names = {f.name for f in schema.factory_fields}
-        assert factory_names == {'items', 'data'}
+        obj1.inner.value = 'modified'
 
-    def test__class_with_nested__nested_fields(self):
-        schema = type_safe_fast_create_cache.generate_schema(TS__With_Nested)
+        assert obj1.inner.value == 'modified'
+        assert obj2.inner.value == ''                                             # Not shared!
 
-        assert len(schema.nested_fields)    == 1
-        assert schema.nested_fields[0].name == 'inner'
-        assert schema.nested_fields[0].mode == FIELD_MODE__NESTED
-        assert schema.nested_fields[0].nested_class is TS__Inner
+    def test__deep_nested_created(self):
+        with Type_Safe__Config(fast_create=True):
+            obj = TS__Deep()
 
-    def test__deep_nested_class(self):
-        schema = type_safe_fast_create_cache.generate_schema(TS__Deep)
+        assert obj.level1              is not None
+        assert obj.level1.level2       is not None
+        assert obj.level1.level2.data  == ''
 
-        assert len(schema.nested_fields)                == 1
-        assert schema.nested_fields[0].name             == 'level1'
-        assert schema.nested_fields[0].nested_class is TS__Deep_Level1
+    def test__json_works(self):
+        with Type_Safe__Config(fast_create=True):
+            obj = TS__Simple(name='json_test', count=42)
+
+        json_data = obj.json()
+
+        assert json_data['name']   == 'json_test'
+        assert json_data['count']  == 42
+        assert json_data['active'] == False
+
+    def test__isinstance_works(self):
+        with Type_Safe__Config(fast_create=True):
+            obj = TS__Simple()
+
+        assert isinstance(obj, TS__Simple)
+        assert isinstance(obj, Type_Safe__Hypothesis_G)
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
-# Cache Behavior Tests
+# Skip Validation Tests
 # ═══════════════════════════════════════════════════════════════════════════════
 
-class test_schema_cache(TestCase):
+class test_skip_validation(TestCase):
 
     def setUp(self):
         type_safe_fast_create_cache.clear_cache()
 
-    def test__schema_is_cached(self):
-        schema1 = type_safe_fast_create_cache.get_schema(TS__Simple)
-        schema2 = type_safe_fast_create_cache.get_schema(TS__Simple)
+    def test__setattr_works_with_skip_validation(self):
+        with Type_Safe__Config(fast_create=True, skip_validation=True):
+            obj      = TS__Simple()
+            obj.name = 'updated'
 
-        assert schema1 is schema2                                                 # Same instance
+        assert obj.name == 'updated'
 
-    def test__warm_cache__recursive(self):
-        type_safe_fast_create_cache.clear_cache()
-        type_safe_fast_create_cache.warm_cache(TS__Deep)
+    def test__setattr_validates_without_skip_validation(self):
+        with Type_Safe__Config(fast_create=True, skip_validation=False):
+            obj      = TS__Simple()
+            obj.name = 'validated'                                                # Should still work
 
-        assert TS__Deep        in type_safe_fast_create_cache.schema_cache
-        assert TS__Deep_Level1 in type_safe_fast_create_cache.schema_cache
-        assert TS__Deep_Level2 in type_safe_fast_create_cache.schema_cache
-
-    def test__clear_cache(self):
-        type_safe_fast_create_cache.get_schema(TS__Simple)
-        assert len(type_safe_fast_create_cache.schema_cache) > 0
-
-        type_safe_fast_create_cache.clear_cache()
-        assert len(type_safe_fast_create_cache.schema_cache) == 0
+        assert obj.name == 'validated'
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
-# Factory Function Tests
+# Config Context Tests
 # ═══════════════════════════════════════════════════════════════════════════════
 
-class test_factory_functions(TestCase):
+class test_config_context(TestCase):
 
     def setUp(self):
         type_safe_fast_create_cache.clear_cache()
 
-    def test__factory_creates_fresh_instances(self):
-        schema = type_safe_fast_create_cache.get_schema(TS__With_Collections)
+    def test__config_only_active_in_context(self):
+        # Outside context - normal mode
+        obj1 = TS__Simple()
+
+        with Type_Safe__Config(fast_create=True):
+            # Inside context - fast mode
+            obj2 = TS__Simple()
 
-        items_field = next(f for f in schema.factory_fields if f.name == 'items')
+        # Outside context again - normal mode
+        obj3 = TS__Simple()
 
-        instance1 = items_field.factory_func()
-        instance2 = items_field.factory_func()
+        assert type(obj1) is TS__Simple
+        assert type(obj2) is TS__Simple
+        assert type(obj3) is TS__Simple
 
-        assert instance1 is not instance2                                         # Different instances
+    def test__nested_contexts(self):
+        with Type_Safe__Config(fast_create=True):
+            obj1 = TS__Simple()
 
-    def test__type_safe_list_preserves_expected_type(self):
-        schema = type_safe_fast_create_cache.get_schema(TS__With_Collections)
+            with Type_Safe__Config(fast_create=True, skip_validation=True):
+                obj2      = TS__Simple()
+                obj2.name = 'nested'
 
-        items_field = next(f for f in schema.factory_fields if f.name == 'items')
-        items       = items_field.factory_func()
+            obj3 = TS__Simple()
 
-        assert items.expected_type is str
+        assert type(obj1) is TS__Simple
+        assert type(obj2) is TS__Simple
+        assert type(obj3) is TS__Simple
+        assert obj2.name  == 'nested'