test: add comprehensive tests for gts-spec v0.7 changes

Add 11 tests covering all three breaking changes:

Issue #25 tests (2):
- test_issue_25_schema_validation: Verify $schema field validation
- test_store_validation_issue_25: Verify GtsStore rejects GTS IDs in $schema

Issue #31 tests (1):
- test_issue_31_id_extraction_with_gts_prefix: Verify gts:// prefix normalization

Issue #32 tests (8):
- test_issue_32_ref_extraction_with_gts_prefix: Parse gts:// in $ref
- test_store_ref_resolution_issue_32: RefResolver handles gts:// scheme
- test_validate_schema_refs_rejects_bare_gts_id: Reject bare GTS IDs
- test_validate_schema_refs_rejects_external_http_ref: Reject HTTP refs
- test_validate_schema_refs_accepts_local_json_pointer: Accept #/... refs
- test_validate_schema_refs_accepts_gts_uri: Accept gts:// refs
- test_validate_schema_refs_rejects_malformed_gts_id: Reject invalid IDs
- test_validate_schema_refs_nested_invalid_ref: Verify error paths

All tests pass successfully (11/11).

Signed-off-by: Dmitrii Efremov <kaidendev@icloud.com>

Author: KvizadSaderah

test_changes.py

@@ -0,0 +1,301 @@
+import sys
+import os
+import unittest
+from typing import Dict, Any
+
+# Add src to path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "gts/src")))
+
+from gts.entities import GtsConfig, DEFAULT_GTS_CONFIG, GtsEntity, GtsID
+from gts.store import GtsStore, GtsReader
+
+class MockReader(GtsReader):
+    def __init__(self, entities):
+        self.entities = entities
+    def __iter__(self):
+        for e in self.entities:
+            yield e
+    def read_by_id(self, entity_id):
+        for e in self.entities:
+            if e.gts_id and e.gts_id.id == entity_id:
+                return e
+        return None
+    def reset(self):
+        pass
+
+class TestProtocolUpdates(unittest.TestCase):
+
+    def test_issue_25_schema_validation(self):
+        """Issue #25: strict $schema usage."""
+        # 1. Verify defaults
+        self.assertNotIn("$schema", DEFAULT_GTS_CONFIG.schema_id_fields)
+
+        # 2. Verify _is_json_schema_entity logic
+        # Valid JSON Schema
+        valid_schema = {"$schema": "http://json-schema.org/draft-07/schema#", "gtsId": "gts.vendor.pkg.ns.type.v1~"}
+        e = GtsEntity(content=valid_schema, cfg=DEFAULT_GTS_CONFIG)
+        self.assertTrue(e.is_schema, "Should be detected as schema")
+
+        # Invalid: GTS ID in $schema
+        invalid_schema = {"$schema": "gts.vendor.meta.ns.type.v1~", "gtsId": "gts.vendor.pkg.ns.type.v1~"}
+        e = GtsEntity(content=invalid_schema, cfg=DEFAULT_GTS_CONFIG)
+        self.assertFalse(e.is_schema, "Should NOT be detected as schema if $schema is GTS ID")
+
+        # Invalid: gts:// URI in $schema
+        invalid_schema_uri = {"$schema": "gts://gts.vendor.meta.ns.type.v1~", "gtsId": "gts.vendor.pkg.ns.type.v1~"}
+        e = GtsEntity(content=invalid_schema_uri, cfg=DEFAULT_GTS_CONFIG)
+        self.assertFalse(e.is_schema, "Should NOT be detected as schema if $schema is gts://")
+
+    def test_issue_31_id_extraction_with_gts_prefix(self):
+        """Issue #31: Handle gts:// in ID fields."""
+        # Case 1: $id with gts://
+        content = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "$id": "gts://gts.vendor.test.ns.type.v1~",
+            "type": "object"
+        }
+        e = GtsEntity(content=content, cfg=DEFAULT_GTS_CONFIG)
+        self.assertTrue(e.is_schema)
+        self.assertIsNotNone(e.gts_id)
+        self.assertEqual(e.gts_id.id, "gts.vendor.test.ns.type.v1~")
+
+        # Case 2: gtsId with gts://
+        content2 = {
+            "gtsId": "gts://gts.vendor.data.ns.type.v1~",
+            "foo": "bar"
+        }
+        e2 = GtsEntity(content=content2, cfg=DEFAULT_GTS_CONFIG)
+        self.assertIsNotNone(e2.gts_id)
+        self.assertEqual(e2.gts_id.id, "gts.vendor.data.ns.type.v1~")
+
+    def test_issue_32_ref_extraction_with_gts_prefix(self):
+        """Issue #32: Handle gts:// in $ref."""
+        content = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "$id": "gts.vendor.parent.ns.type.v1~",
+            "properties": {
+                "child": {
+                    "$ref": "gts://gts.vendor.child.ns.type.v1~"
+                }
+            }
+        }
+        e = GtsEntity(content=content, cfg=DEFAULT_GTS_CONFIG)
+        
+        # Check extracted refs
+        refs = [r['id'] for r in e.schemaRefs]
+        self.assertIn("gts.vendor.child.ns.type.v1~", refs, "Should strip gts:// from $ref")
+
+    def test_store_validation_issue_25(self):
+        """Verify Store.validate_schema enforces Issue #25."""
+        store = GtsStore(None)
+        
+        # Create a schema entity with invalid $schema
+        # Note: We manually set is_schema=True because auto-detect might fail (as tested above)
+        # But for the store validation to even run, we need to register it.
+        bad_schema_id = "gts.vendor.bad.ns.type.v1~"
+        bad_content = {
+            "$schema": "gts.vendor.meta.ns.type.v1~",
+            "$id": bad_schema_id,
+            "type": "object"
+        }
+        # Force it into store
+        entity = GtsEntity(content=bad_content, gts_id=GtsID(bad_schema_id), is_schema=True)
+        store.register(entity)
+
+        # Validate
+        with self.assertRaises(ValueError) as cm:
+            store.validate_schema(bad_schema_id)
+        self.assertIn("Invalid $schema URL", str(cm.exception))
+
+    def test_store_ref_resolution_issue_32(self):
+        """Verify RefResolver handles gts:// scheme."""
+        # 1. Register a target schema
+        target_id = "gts.vendor.target.ns.type.v1~"
+        target_content = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "$id": target_id,
+            "type": "string"
+        }
+        target_entity = GtsEntity(content=target_content, cfg=DEFAULT_GTS_CONFIG)
+        
+        # 2. Register a source schema referring to it via gts://
+        source_id = "gts.vendor.source.ns.type.v1~"
+        source_content = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "$id": source_id,
+            "type": "object",
+            "properties": {
+                "prop": { "$ref": f"gts://{target_id}" }
+            }
+        }
+        source_entity = GtsEntity(content=source_content, cfg=DEFAULT_GTS_CONFIG)
+
+        store = GtsStore(MockReader([target_entity, source_entity]))
+        
+        # 3. Create an instance to validate
+        instance_id = "gts.vendor.source.ns.type.v1~vendor.pkg.ns.type.v1"
+        instance_content = {
+            "gtsId": instance_id,
+            "prop": "valid string"
+        }
+        instance_entity = GtsEntity(content=instance_content, schemaId=source_id, gts_id=GtsID(instance_id))
+        store.register(instance_entity)
+
+        # 4. Validate
+        try:
+            store.validate_instance(instance_id)
+        except Exception as e:
+            self.fail(f"Validation failed with gts:// ref: {e}")
+
+    def test_validate_schema_refs_rejects_bare_gts_id(self):
+        """Issue #32: Bare GTS IDs in $ref must be rejected."""
+        store = GtsStore(None)
+        
+        schema_id = "gts.vendor.bad.ns.type.v1~"
+        content = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "$id": schema_id,
+            "properties": {
+                "child": {
+                    "$ref": "gts.vendor.other.ns.type.v1~"
+                }
+            }
+        }
+        entity = GtsEntity(content=content, gts_id=GtsID(schema_id), is_schema=True)
+        store.register(entity)
+        
+        with self.assertRaises(ValueError) as cm:
+            store.validate_schema(schema_id)
+        self.assertIn("must be a local ref", str(cm.exception))
+        self.assertIn("or a GTS URI", str(cm.exception))
+
+    def test_validate_schema_refs_rejects_external_http_ref(self):
+        """Issue #32: External HTTP refs must be rejected."""
+        store = GtsStore(None)
+        
+        schema_id = "gts.vendor.bad.ns.type.v1~"
+        content = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "$id": schema_id,
+            "properties": {
+                "child": {
+                    "$ref": "http://example.com/schema.json"
+                }
+            }
+        }
+        entity = GtsEntity(content=content, gts_id=GtsID(schema_id), is_schema=True)
+        store.register(entity)
+        
+        with self.assertRaises(ValueError) as cm:
+            store.validate_schema(schema_id)
+        self.assertIn("must be a local ref", str(cm.exception))
+
+    def test_validate_schema_refs_accepts_local_json_pointer(self):
+        """Issue #32: Local JSON Pointer refs should be accepted."""
+        store = GtsStore(None)
+        
+        schema_id = "gts.vendor.good.ns.type.v1~"
+        content = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "$id": schema_id,
+            "definitions": {
+                "Base": {"type": "string"}
+            },
+            "properties": {
+                "child": {
+                    "$ref": "#/definitions/Base"
+                }
+            }
+        }
+        entity = GtsEntity(content=content, gts_id=GtsID(schema_id), is_schema=True)
+        store.register(entity)
+        
+        try:
+            store.validate_schema(schema_id)
+        except ValueError as e:
+            if "$ref" in str(e):
+                self.fail(f"Local ref should be accepted: {e}")
+
+    def test_validate_schema_refs_accepts_gts_uri(self):
+        """Issue #32: GTS URIs with gts:// prefix should be accepted."""
+        target_id = "gts.vendor.target.ns.type.v1~"
+        target_content = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "$id": target_id,
+            "type": "string"
+        }
+        target_entity = GtsEntity(content=target_content, cfg=DEFAULT_GTS_CONFIG)
+        
+        schema_id = "gts.vendor.good.ns.type.v1~"
+        content = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "$id": schema_id,
+            "properties": {
+                "child": {
+                    "$ref": f"gts://{target_id}"
+                }
+            }
+        }
+        entity = GtsEntity(content=content, gts_id=GtsID(schema_id), is_schema=True)
+        
+        store = GtsStore(MockReader([target_entity, entity]))
+        
+        try:
+            store.validate_schema(schema_id)
+        except ValueError as e:
+            if "$ref" in str(e):
+                self.fail(f"gts:// ref should be accepted: {e}")
+
+    def test_validate_schema_refs_rejects_malformed_gts_id(self):
+        """Issue #32: Malformed GTS IDs after gts:// should be rejected."""
+        store = GtsStore(None)
+        
+        schema_id = "gts.vendor.bad.ns.type.v1~"
+        content = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "$id": schema_id,
+            "properties": {
+                "child": {
+                    "$ref": "gts://invalid-gts-id"
+                }
+            }
+        }
+        entity = GtsEntity(content=content, gts_id=GtsID(schema_id), is_schema=True)
+        store.register(entity)
+        
+        with self.assertRaises(ValueError) as cm:
+            store.validate_schema(schema_id)
+        self.assertIn("invalid GTS identifier", str(cm.exception))
+
+    def test_validate_schema_refs_nested_invalid_ref(self):
+        """Issue #32: Nested invalid refs should report correct path."""
+        store = GtsStore(None)
+        
+        schema_id = "gts.vendor.bad.ns.type.v1~"
+        content = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "$id": schema_id,
+            "properties": {
+                "level1": {
+                    "properties": {
+                        "level2": {
+                            "properties": {
+                                "level3": {
+                                    "$ref": "invalid-external-ref"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        entity = GtsEntity(content=content, gts_id=GtsID(schema_id), is_schema=True)
+        store.register(entity)
+        
+        with self.assertRaises(ValueError) as cm:
+            store.validate_schema(schema_id)
+        error_msg = str(cm.exception)
+        self.assertIn("properties.level1.properties.level2.properties.level3.$ref", error_msg)
+
+if __name__ == '__main__':
+    unittest.main()