lutaml-model 0.7.7 → 0.8.0

data/spec/lutaml/model/global_context_spec.rb

@@ -0,0 +1,421 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::GlobalContext do
+  before do
+    # Reset global state before each test
+    described_class.reset!
+  end
+
+  describe ".instance" do
+    it "returns a singleton instance" do
+      expect(described_class.instance).to eq(described_class.instance)
+    end
+  end
+
+  describe "#initialize" do
+    it "creates a ContextRegistry" do
+      expect(described_class.registry).to be_a(Lutaml::Model::ContextRegistry)
+    end
+
+    it "creates a CachedTypeResolver" do
+      expect(described_class.resolver).to be_a(Lutaml::Model::CachedTypeResolver)
+    end
+
+    it "creates an ImportRegistry" do
+      expect(described_class.imports).to be_a(Lutaml::Model::ImportRegistry)
+    end
+
+    it "sets default_context_id to :default" do
+      expect(described_class.default_context_id).to eq(:default)
+    end
+  end
+
+  describe "#default_context" do
+    it "returns the default context" do
+      expect(described_class.default_context.id).to eq(:default)
+    end
+  end
+
+  describe "#default_context_id=" do
+    it "sets the default context ID" do
+      described_class.create_context(id: :my_app)
+      described_class.default_context_id = :my_app
+      expect(described_class.default_context_id).to eq(:my_app)
+    end
+  end
+
+  describe "#context" do
+    it "returns default context when no ID provided" do
+      expect(described_class.context.id).to eq(:default)
+    end
+
+    it "returns specific context when ID provided" do
+      described_class.create_context(id: :my_app)
+      expect(described_class.context(:my_app).id).to eq(:my_app)
+    end
+
+    it "returns nil for unknown context" do
+      expect(described_class.context(:unknown)).to be_nil
+    end
+  end
+
+  describe "#resolve_type" do
+    it "resolves types using default context" do
+      result = described_class.resolve_type(:string)
+      expect(result).to eq(Lutaml::Model::Type::String)
+    end
+
+    it "resolves types using specific context" do
+      registry = Lutaml::Model::TypeRegistry.new
+      custom_class = Class.new
+      registry.register(:custom, custom_class)
+
+      described_class.create_context(id: :custom_ctx, registry: registry)
+      result = described_class.resolve_type(:custom, :custom_ctx)
+      expect(result).to eq(custom_class)
+    end
+
+    it "raises UnknownTypeError for unknown types" do
+      expect do
+        described_class.resolve_type(:nonexistent)
+      end.to raise_error(Lutaml::Model::UnknownTypeError)
+    end
+  end
+
+  describe "#resolvable?" do
+    it "returns true for resolvable types" do
+      expect(described_class.resolvable?(:string)).to be true
+    end
+
+    it "returns false for unresolvable types" do
+      expect(described_class.resolvable?(:nonexistent)).to be false
+    end
+  end
+
+  describe "#register_context" do
+    it "registers a context" do
+      registry = Lutaml::Model::TypeRegistry.new
+      context = Lutaml::Model::TypeContext.isolated(:my_app, registry)
+      described_class.register_context(context)
+
+      expect(described_class.context(:my_app)).to eq(context)
+    end
+  end
+
+  describe "#create_context" do
+    it "creates and registers a context" do
+      context = described_class.create_context(id: :my_app)
+      expect(context.id).to eq(:my_app)
+      expect(described_class.context(:my_app)).to eq(context)
+    end
+
+    it "accepts fallback_to with symbols" do
+      context = described_class.create_context(id: :my_app,
+                                               fallback_to: [:default])
+      expect(context.has_fallbacks?).to be true
+    end
+
+    it "accepts substitutions" do
+      from_class = Class.new
+      context = described_class.create_context(
+        id: :my_app,
+        substitutions: [{ from_type: from_class,
+                          to_type: Lutaml::Model::Type::String }],
+      )
+      expect(context.substitutions.size).to eq(1)
+    end
+  end
+
+  describe "#unregister_context" do
+    before do
+      described_class.create_context(id: :my_app, fallback_to: [:default])
+    end
+
+    it "removes a context" do
+      described_class.unregister_context(:my_app)
+      expect(described_class.context(:my_app)).to be_nil
+    end
+
+    it "clears cache for the context" do
+      # Resolve a type to populate cache
+      described_class.resolve_type(:string, :my_app)
+
+      # Unregister
+      described_class.unregister_context(:my_app)
+
+      # Cache should be cleared
+      stats = described_class.resolver.cache_stats
+      expect(stats[:keys]).not_to include("my_app:string")
+    end
+  end
+
+  describe "#with_context" do
+    before do
+      described_class.create_context(id: :my_app)
+    end
+
+    it "executes block with specified context" do
+      described_class.with_context(:my_app) do
+        expect(described_class.default_context.id).to eq(:my_app)
+      end
+    end
+
+    it "restores previous context after block" do
+      original_id = described_class.default_context.id
+
+      described_class.with_context(:my_app) do
+        # Inside block
+      end
+
+      expect(described_class.default_context.id).to eq(original_id)
+    end
+
+    it "restores context even on exception" do
+      original_id = described_class.default_context.id
+
+      begin
+        described_class.with_context(:my_app) do
+          raise "Test error"
+        end
+      rescue RuntimeError
+        # Expected
+      end
+
+      expect(described_class.default_context.id).to eq(original_id)
+    end
+  end
+
+  describe "#reset!" do
+    before do
+      described_class.create_context(id: :ctx1)
+      described_class.create_context(id: :ctx2)
+      described_class.resolve_type(:string)
+      described_class.imports.defer(Class.new, method: :author, symbol: :Person)
+    end
+
+    it "clears non-default contexts" do
+      described_class.reset!
+      expect(described_class.context(:ctx1)).to be_nil
+      expect(described_class.context(:ctx2)).to be_nil
+    end
+
+    it "clears resolver cache" do
+      described_class.reset!
+      expect(described_class.resolver.cache_stats[:size]).to eq(0)
+    end
+
+    it "clears imports" do
+      described_class.reset!
+      expect(described_class.imports.stats[:total_imports]).to eq(0)
+    end
+
+    it "resets default context ID" do
+      described_class.default_context_id = :ctx1
+      described_class.reset!
+      expect(described_class.default_context_id).to eq(:default)
+    end
+
+    it "keeps default context" do
+      described_class.reset!
+      expect(described_class.context(:default)).not_to be_nil
+    end
+  end
+
+  describe "#clear_caches" do
+    before do
+      described_class.resolve_type(:string)
+      described_class.resolve_type(:integer)
+    end
+
+    it "clears resolver cache" do
+      expect(described_class.resolver.cache_stats[:size]).to be > 0
+      described_class.clear_caches
+      expect(described_class.resolver.cache_stats[:size]).to eq(0)
+    end
+
+    it "does not remove contexts" do
+      described_class.create_context(id: :my_app)
+      described_class.clear_caches
+      expect(described_class.context(:my_app)).not_to be_nil
+    end
+  end
+
+  describe "#stats" do
+    before do
+      described_class.create_context(id: :my_app)
+      described_class.resolve_type(:string)
+    end
+
+    it "returns statistics" do
+      stats = described_class.stats
+      expect(stats).to have_key(:contexts)
+      expect(stats).to have_key(:default_context_id)
+      expect(stats).to have_key(:resolver_cache_size)
+      expect(stats).to have_key(:imports)
+    end
+
+    it "includes context IDs" do
+      stats = described_class.stats
+      expect(stats[:contexts]).to include(:default, :my_app)
+    end
+
+    it "includes cache size" do
+      stats = described_class.stats
+      expect(stats[:resolver_cache_size]).to be >= 1
+    end
+  end
+
+  describe "delegation to class methods" do
+    it "delegates registry to instance" do
+      expect(described_class.registry).to eq(described_class.instance.registry)
+    end
+
+    it "delegates resolver to instance" do
+      expect(described_class.resolver).to eq(described_class.instance.resolver)
+    end
+
+    it "delegates resolve_type to instance" do
+      result = described_class.resolve_type(:string)
+      expect(result).to eq(Lutaml::Model::Type::String)
+    end
+
+    it "delegates reset! to instance" do
+      described_class.create_context(id: :test_ctx)
+      described_class.reset!
+      expect(described_class.context(:test_ctx)).to be_nil
+    end
+  end
+
+  describe "thread safety" do
+    it "handles concurrent context switching" do
+      described_class.create_context(id: :ctx1)
+      described_class.create_context(id: :ctx2)
+
+      results = []
+
+      threads = Array.new(2) do |i|
+        Thread.new do
+          ctx_id = i.even? ? :ctx1 : :ctx2
+          described_class.with_context(ctx_id) do
+            sleep(0.001) # Small delay to increase chance of race conditions
+            results << described_class.default_context.id
+          end
+        end
+      end
+
+      threads.each(&:join)
+
+      # Each thread should have seen its own context
+      expect(results).to contain_exactly(:ctx1, :ctx2)
+    end
+
+    it "handles concurrent resolve_type calls" do
+      threads = Array.new(10) do
+        Thread.new do
+          100.times { described_class.resolve_type(:string) }
+        end
+      end
+
+      threads.each(&:join)
+      # Should not raise any errors
+    end
+  end
+
+  describe "integration" do
+    it "provides complete workflow" do
+      # Create a custom context
+      custom_registry = Lutaml::Model::TypeRegistry.new
+      custom_class = Class.new
+      custom_registry.register(:custom, custom_class)
+
+      described_class.create_context(
+        id: :my_app,
+        registry: custom_registry,
+        fallback_to: [:default],
+      )
+
+      # Resolve custom type
+      result = described_class.resolve_type(:custom, :my_app)
+      expect(result).to eq(custom_class)
+
+      # Resolve built-in type from fallback
+      result = described_class.resolve_type(:string, :my_app)
+      expect(result).to eq(Lutaml::Model::Type::String)
+
+      # Use with_context
+      described_class.with_context(:my_app) do
+        expect(described_class.resolve_type(:custom)).to eq(custom_class)
+      end
+
+      # Reset for isolation
+      described_class.reset!
+      expect(described_class.context(:my_app)).to be_nil
+    end
+  end
+
+  describe "#xml_namespace_registry" do
+    it "returns an Xml::NamespaceClassRegistry instance" do
+      expect(described_class.xml_namespace_registry).to be_a(Lutaml::Xml::NamespaceClassRegistry)
+    end
+
+    it "returns the same instance on subsequent calls" do
+      registry1 = described_class.xml_namespace_registry
+      registry2 = described_class.xml_namespace_registry
+      expect(registry1).to eq(registry2)
+    end
+
+    it "is reset by reset!" do
+      # Create a namespace class
+      described_class.xml_namespace_registry.get_or_create(
+        uri: "http://example.com",
+        prefix: "ex",
+      )
+
+      # Reset
+      described_class.reset!
+
+      # Create again - should be a new registry
+      # (can't directly test clearing, but we verify reset! doesn't raise)
+      expect { described_class.xml_namespace_registry }.not_to raise_error
+    end
+  end
+
+  describe "#clear_xml_namespace_registry!" do
+    it "clears the XML namespace registry" do
+      # Create a namespace class
+      described_class.xml_namespace_registry.get_or_create(
+        uri: "http://example.com",
+        prefix: "ex",
+      )
+
+      # Clear
+      described_class.clear_xml_namespace_registry!
+
+      # Should not raise
+      expect { described_class.xml_namespace_registry }.not_to raise_error
+    end
+  end
+
+  describe "Single Entry Point Architecture" do
+    it "provides access to all global registries through GlobalContext" do
+      expect(described_class.registry).to be_a(Lutaml::Model::ContextRegistry)
+      expect(described_class.resolver).to be_a(Lutaml::Model::CachedTypeResolver)
+      expect(described_class.imports).to be_a(Lutaml::Model::ImportRegistry)
+      expect(described_class.xml_namespace_registry).to be_a(Lutaml::Xml::NamespaceClassRegistry)
+    end
+
+    it "clears all registries with reset!" do
+      # Setup some state in each registry
+      described_class.create_context(id: :test_ctx)
+      described_class.xml_namespace_registry.get_or_create(uri: "http://test.com")
+
+      # Reset
+      described_class.reset!
+
+      # Verify all cleared
+      expect(described_class.context(:test_ctx)).to be_nil
+    end
+  end
+end

data/spec/lutaml/model/global_register_spec.rb

@@ -3,43 +3,62 @@
 require "spec_helper"
 
 RSpec.describe Lutaml::Model::GlobalRegister do
+  # GlobalRegister is now a pure facade that delegates to GlobalContext
+  # Tests verify the public API behavior, not internal implementation
+
   describe "#initialize" do
-    it "initializes with a default register" do
-      expect(described_class.instance.instance_variable_get(:@registers)).to include(default: described_class.lookup(:default))
+    it "initializes with a default context" do
+      expect(described_class.lookup(:default)).not_to be_nil
     end
   end
 
   describe "#register" do
-    it "adds register to the internal hash" do
+    after do
+      described_class.remove(:test_register) if described_class.lookup(:test_register)
+    end
+
+    it "returns the register for backward compatibility" do
       register = Lutaml::Model::Register.new(:test_register)
-      described_class.register(register)
+      result = described_class.register(register)
+      expect(result).to eq(register)
+    end
 
-      registers = described_class.instance.instance_variable_get(:@registers)
-      expect(registers[:test_register]).to eq(register)
+    it "makes the register available via lookup" do
+      register = Lutaml::Model::Register.new(:test_register)
+      described_class.register(register)
+      expect(described_class.lookup(:test_register)).not_to be_nil
     end
   end
 
   describe ".register" do
-    it "calls instance method to register" do
+    after do
+      described_class.remove(:temp_register) if described_class.lookup(:temp_register)
+    end
+
+    it "makes register available via lookup" do
       register = Lutaml::Model::Register.new(:temp_register)
-      expect { described_class.register(register) }.to(
-        change { described_class.instance.instance_variable_get(:@registers).count }.by(1),
-      )
+      described_class.register(register)
+      expect(described_class.lookup(:temp_register)).not_to be_nil
     end
   end
 
   describe "#lookup" do
-    let(:register_v_one) { Lutaml::Model::Register.new(:v1) }
-    let(:register_v_two) { Lutaml::Model::Register.new(:v2) }
+    let(:register_v_one) { Lutaml::Model::Register.new(:v1_lookup_test) }
+    let(:register_v_two) { Lutaml::Model::Register.new(:v2_lookup_test) }
 
     before do
       described_class.instance.register(register_v_one)
       described_class.instance.register(register_v_two)
     end
 
-    it "returns the correct register for a given id" do
-      expect(described_class.instance.lookup(:v1)).to eq(register_v_one)
-      expect(described_class.instance.lookup(:v2)).to eq(register_v_two)
+    after do
+      described_class.remove(:v1_lookup_test)
+      described_class.remove(:v2_lookup_test)
+    end
+
+    it "returns a register for a given id" do
+      expect(described_class.instance.lookup(:v1_lookup_test)).not_to be_nil
+      expect(described_class.instance.lookup(:v2_lookup_test)).not_to be_nil
     end
 
     it "returns nil for non-existent id" do
@@ -47,17 +66,58 @@ RSpec.describe Lutaml::Model::GlobalRegister do
     end
 
     it "converts string id to symbol" do
-      expect(described_class.instance.lookup("v1")).to eq(register_v_one)
+      expect(described_class.instance.lookup("v1_lookup_test")).not_to be_nil
+    end
+
+    context "when context exists in GlobalContext but no Register was registered" do
+      let(:context_id) { :context_only_test }
+
+      before do
+        Lutaml::Model::GlobalContext.create_context(
+          id: context_id,
+          fallback_to: [:default],
+        )
+      end
+
+      after do
+        described_class.remove(context_id) if described_class.lookup(context_id)
+        Lutaml::Model::GlobalContext.unregister_context(context_id)
+      end
+
+      it "creates a Register from the context and returns it" do
+        result = described_class.lookup(context_id)
+        expect(result).to be_a(Lutaml::Model::Register)
+        expect(result.id).to eq(context_id)
+      end
+
+      it "caches the created Register for subsequent lookups" do
+        first_result = described_class.lookup(context_id)
+        second_result = described_class.lookup(context_id)
+        expect(first_result).to be(second_result)
+      end
+
+      it "resolves types registered in the context through the created Register" do
+        custom_class = Class.new(Lutaml::Model::Type::Value)
+        ctx = Lutaml::Model::GlobalContext.context(context_id)
+        ctx.registry.register(:custom_type, custom_class)
+
+        described_class.lookup(context_id)
+        resolved = Lutaml::Model::GlobalContext.resolve_type(:custom_type,
+                                                             context_id)
+        expect(resolved).to eq(custom_class)
+      end
+
+      it "resolves built-in types via fallback to default context" do
+        register = described_class.lookup(context_id)
+        result = register.get_class_without_register(:string)
+        expect(result).to eq(Lutaml::Model::Type::String)
+      end
     end
   end
 
   describe ".lookup" do
-    let(:register_v_one) { Lutaml::Model::Register.new(:v1) }
-
-    it "calls instance method to lookup" do
-      allow(described_class.instance).to receive(:lookup).with(:v1).and_return(register_v_one)
-
-      expect(described_class.lookup(:v1)).to eq(register_v_one)
+    it "delegates to instance method" do
+      expect(described_class.lookup(:default)).not_to be_nil
     end
   end
 
@@ -72,37 +132,94 @@ RSpec.describe Lutaml::Model::GlobalRegister do
     it "shares state between method calls" do
       register = Lutaml::Model::Register.new(:shared_test)
       described_class.register(register)
-      expect(described_class.lookup(:shared_test)).to eq(register)
+      expect(described_class.lookup(:shared_test)).not_to be_nil
+      described_class.remove(:shared_test)
     end
   end
 
   describe "#remove" do
-    let(:register_v_one) { Lutaml::Model::Register.new(:v1) }
-    let(:register_v_two) { Lutaml::Model::Register.new(:v2) }
+    let(:register_v_one) { Lutaml::Model::Register.new(:v1_remove_test) }
+    let(:register_v_two) { Lutaml::Model::Register.new(:v2_remove_test) }
 
     before do
       described_class.register(register_v_one)
       described_class.register(register_v_two)
     end
 
+    after do
+      described_class.remove(:v1_remove_test) if described_class.lookup(:v1_remove_test)
+      described_class.remove(:v2_remove_test) if described_class.lookup(:v2_remove_test)
+    end
+
     it "removes the specified register" do
-      register = described_class.instance
-      expect(register.instance_variable_get(:@registers).values).to include(register_v_one)
-      expect { described_class.remove(:v1) }.to(
-        change { register.instance_variable_get(:@registers).values.count }.by(-1),
-      )
-      expect(register.instance_variable_get(:@registers).values).not_to include(register_v_one)
+      expect(described_class.lookup(:v1_remove_test)).not_to be_nil
+      described_class.remove(:v1_remove_test)
+      expect(described_class.lookup(:v1_remove_test)).to be_nil
     end
 
     it "does not remove other registers" do
-      described_class.remove(:v1)
-      registers = described_class.instance.instance_variable_get(:@registers)
-      expect(registers.values).to include(register_v_two)
+      described_class.remove(:v1_remove_test)
+      expect(described_class.lookup(:v2_remove_test)).not_to be_nil
     end
 
     it "does nothing when the specified register does not exist" do
-      registers = described_class.instance.instance_variable_get(:@registers)
-      expect { described_class.remove(:non_existent) }.not_to(change { registers.values.count })
+      expect { described_class.remove(:non_existent) }.not_to raise_error
+    end
+  end
+
+  describe "GlobalContext fallback integration" do
+    let(:context_id) { :fallback_integration_test }
+
+    after do
+      described_class.remove(context_id) if described_class.lookup(context_id)
+      Lutaml::Model::GlobalContext.unregister_context(context_id)
+    end
+
+    context "when a model is registered only via GlobalContext" do
+      let(:test_model) do
+        klass = Class.new(Lutaml::Model::Serializable) do
+          attribute :name, :string
+
+          json do
+            map "name", to: :name
+          end
+        end
+        # Stub a name so type resolution works
+        stub_const("FallbackTestModel", klass)
+        klass
+      end
+
+      before do
+        registry = Lutaml::Model::TypeRegistry.new
+        registry.register(:fallback_test_model, test_model)
+
+        Lutaml::Model::GlobalContext.create_context(
+          id: context_id,
+          registry: registry,
+          fallback_to: [:default],
+        )
+      end
+
+      it "looks up the register via GlobalRegister and resolves the model" do
+        register = described_class.lookup(context_id)
+        expect(register).to be_a(Lutaml::Model::Register)
+
+        result = register.get_class_without_register(:fallback_test_model)
+        expect(result).to eq(test_model)
+      end
+
+      it "mapping register resolution finds the context-only register" do
+        mapping = Lutaml::Model::Mapping.new
+        register = mapping.send(:register, context_id)
+        expect(register).to be_a(Lutaml::Model::Register)
+        expect(register.id).to eq(context_id)
+      end
+    end
+
+    context "when context does not exist in either GlobalRegister or GlobalContext" do
+      it "returns nil" do
+        expect(described_class.lookup(:totally_nonexistent)).to be_nil
+      end
     end
   end
 end