lutaml-model 0.7.7 → 0.8.0

data/spec/lutaml/{model/schema/xml_compiler_spec.rb → xml/schema/compiler_spec.rb}

@@ -1,18 +1,68 @@
 require "spec_helper"
+require "net/http"
 require "lutaml/model/schema"
-require "lutaml/xsd"
+require "support/xml/schema_helper"
 
 RSpec.describe Lutaml::Model::Schema::XmlCompiler do
+  # Reset :default context before each test to prevent pollution
+  # Each test generates classes that register in :default context,
+  # so we need a clean slate with only built-in types
+  before do
+    default_ctx = Lutaml::Model::GlobalContext.context(:default)
+    if default_ctx
+      # Clear all registered types and re-add only built-in types
+      default_ctx.registry.clear
+      Lutaml::Model::Type.register_builtin_types_in(default_ctx.registry)
+    end
+  end
+
+  # Helper method to strip XML comments for comparison
+  # Loop to handle nested/adjacent comments that may create new <!-- patterns
+  def strip_xml_comments(xml)
+    previous = nil
+    current = xml
+    while current != previous
+      previous = current
+      current = current.gsub(/<!--.*?-->/m, "")
+    end
+    current
+  end
+
+  describe ".as_models" do
+    let(:xml_namespace_schema) do
+      <<~XSD
+        <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                   targetNamespace="http://www.w3.org/XML/1998/namespace">
+          <xs:attribute name="id" type="xs:ID"/>
+        </xs:schema>
+      XSD
+    end
+
+    it "keeps built-in W3C XML attribute types when processing xml.xsd" do
+      described_class.as_models(xml_namespace_schema)
+
+      expect(described_class.attributes["id"].type)
+        .to eq("Lutaml::Xml::W3c::XmlIdType")
+    end
+  end
+
   describe ".to_models" do
     describe "Testing the unofficial schemas" do
       context "with valid xml schema, it generates the models" do
         before do
-          described_class.to_models(schema, output_dir: dir, create_files: true)
-          Dir.each_child(dir) { |child| require_relative File.expand_path("#{dir}/#{child}") }
+          described_class.to_models(schema, output_dir: dir,
+                                            create_files: true, module_namespace: nil)
+          Dir.each_child(dir) do |child|
+            require_relative File.expand_path("#{dir}/#{child}")
+          end
         end
 
         after do
           FileUtils.rm_rf(dir)
+          # Clean up dynamically generated classes to prevent test pollution
+          Object.send(:remove_const, :CTMathTest) if defined?(CTMathTest)
+          Object.send(:remove_const, :StInteger255) if defined?(StInteger255)
+          Object.send(:remove_const, :Long) if defined?(Long)
         end
 
         let(:dir) { Dir.mktmpdir }
@@ -48,11 +98,13 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
         end
 
         it "creates the model files, requires them, and tests them with valid and invalid xml" do
-          expect(CTMathTest.from_xml(valid_value_xml_example).to_xml).to be_equivalent_to(valid_value_xml_example)
+          expect(CTMathTest.from_xml(valid_value_xml_example).to_xml).to be_xml_equivalent_to(valid_value_xml_example)
         end
 
         it "raises error when processing invalid example" do
-          expect { CTMathTest.from_xml(invalid_value_xml_example) }.to raise_error(Lutaml::Model::Type::MinBoundError)
+          expect do
+            CTMathTest.from_xml(invalid_value_xml_example)
+          end.to raise_error(Lutaml::Model::Type::MinBoundError)
         end
       end
 
@@ -63,20 +115,25 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
               File.read("spec/fixtures/xml/math_document_schema.xsd"),
               output_dir: dir,
               create_files: true,
+              module_namespace: nil,
             )
             require_relative "#{dir}/math_document"
           end
         end
 
-        let(:valid_example) { File.read("spec/fixtures/xml/valid_math_document.xml") }
-        let(:invalid_example) { File.read("spec/fixtures/xml/invalid_math_document.xml") }
+        let(:valid_example) do
+          File.read("spec/fixtures/xml/valid_math_document.xml")
+        end
+        let(:invalid_example) do
+          File.read("spec/fixtures/xml/invalid_math_document.xml")
+        end
 
         it "does not raise error with valid example and creates files" do
           expect(defined?(MathDocument)).to eq("constant")
           parsed = MathDocument.from_xml(valid_example)
           expect(parsed.title).to eql("Example Title")
           expect(parsed.ipv4_address).to eql("192.168.1.1")
-          expect(parsed.to_xml).to be_equivalent_to(valid_example)
+          expect(parsed.to_xml).to be_xml_equivalent_to(valid_example)
         end
 
         it "raises PatternNotMatchedError" do
@@ -88,16 +145,25 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
 
       context "when processing example from lutaml-model#260" do
         before do
+          # Remove any existing Address constant to prevent test pollution
+          Object.send(:remove_const, :Address) if defined?(Address)
+
           Dir.mktmpdir do |dir|
             described_class.to_models(
               File.read("spec/fixtures/xml/address_example_260.xsd"),
               output_dir: dir,
               create_files: true,
+              module_namespace: nil,
             )
-            require_relative "#{dir}/address"
+            load "#{dir}/address.rb"
           end
         end
 
+        after do
+          # Clean up the Address constant to prevent test pollution
+          Object.send(:remove_const, :Address) if defined?(Address)
+        end
+
         let(:address) do
           <<~ADD
             <Address>
@@ -110,7 +176,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
 
         it "matches parsed xml with input" do
           expect(defined?(Address)).to eq("constant")
-          expect(Address.from_xml(address).to_xml).to be_equivalent_to(address)
+          expect(Address.from_xml(address).to_xml).to be_xml_equivalent_to(address)
         end
       end
 
@@ -121,6 +187,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
               File.read("spec/fixtures/xml/product_catalog.xsd"),
               output_dir: dir,
               create_files: true,
+              module_namespace: nil,
             )
             require_relative "#{dir}/product_catalog"
           end
@@ -149,16 +216,22 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
 
       context "when classes are generated but files are not created" do
         let(:schema_classes_hash) do
-          described_class.to_models(File.read("spec/fixtures/xml/user.xsd"))
+          described_class.to_models(File.read("spec/fixtures/xml/user.xsd"),
+                                    module_namespace: nil)
         end
 
         let(:expected_classes) do
           types = described_class::SimpleType::SUPPORTED_DATA_TYPES
-          types.filter_map { |name, value| name.to_s unless value[:skippable] } << "User"
+          classes = types.filter_map do |name, value|
+            name.to_s unless value[:skippable]
+          end
+          classes << "User"
+          # W3C xml: namespace is now built-in, no custom class generated
+          classes.sort
         end
 
         it "matches the expected class names of the schema" do
-          expect(schema_classes_hash.keys).to eql(expected_classes)
+          expect(schema_classes_hash.keys.sort).to eql(expected_classes)
         end
       end
 
@@ -167,6 +240,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
           described_class.to_models(
             File.read("spec/fixtures/xml/user.xsd"),
             load_classes: true,
+            module_namespace: nil,
           )
         end
 
@@ -198,14 +272,19 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
           expected_classes.each do |klass|
             expect(be_const_defined(klass)).to be_truthy
           end
-          expect(User.from_xml(xml).to_xml).to be_equivalent_to(xml)
+          expect(User.from_xml(xml).to_xml).to be_xml_equivalent_to(xml)
         end
       end
 
       context "when classes are generated and loaded but files are not created for specifications schema" do
-        before { described_class.to_models(schema, load_classes: true) }
+        before do
+          described_class.to_models(schema, load_classes: true,
+                                            module_namespace: nil)
+        end
 
-        let(:schema) { File.read("spec/fixtures/xml/specifications_schema.xsd") }
+        let(:schema) do
+          File.read("spec/fixtures/xml/specifications_schema.xsd")
+        end
 
         let(:spec_xml) do
           <<~XML
@@ -227,53 +306,53 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
           XML
         end
 
+        after do
+          # Clean up dynamically generated classes to prevent test pollution
+          Object.send(:remove_const, :Spec) if defined?(Spec)
+          Object.send(:remove_const, :ShortSpec) if defined?(ShortSpec)
+        end
+
         it "successfully processes the Spec example" do
-          expect(Spec.from_xml(spec_xml).to_xml).to be_equivalent_to(spec_xml)
+          expect(Spec.from_xml(spec_xml).to_xml).to be_xml_equivalent_to(spec_xml)
         end
 
         it "successfully processes the ShortSpec example" do
-          expect(ShortSpec.from_xml(short_spec_xml).to_xml).to be_equivalent_to(short_spec_xml)
+          expect(ShortSpec.from_xml(short_spec_xml).to_xml).to be_xml_equivalent_to(short_spec_xml)
         end
       end
     end
 
     describe "Testing the official schemas" do
-      before do
-        Lutaml::Model::GlobalRegister.register(Lutaml::Model::Register.new(register_id))
-        Lutaml::Model::Config.default_register = register_id
-      end
-
-      after do
-        Lutaml::Model::Config.default_register = :default
-      end
-
-      let(:namespaced_classes) do
-        Dir.mktmpdir do |dir|
-          loaded_classes.each do |name, klass|
-            content = "module #{module_name}\n#{klass}\nend\n"
-            File.write(File.join(dir, "#{Lutaml::Model::Utils.snake_case(name)}.rb"), content)
-          end
-          loaded_classes.each_key { |name| require File.join(dir, "#{Lutaml::Model::Utils.snake_case(name)}.rb") }
-        end
-      end
-
       context "when classes are generated and loaded but files are not created for OOXML schema" do
         before do
-          loaded_classes.merge!(
-            described_class.to_models(
-              Net::HTTP.get(URI("#{schema_location}/shared-math.xsd")),
-              location: schema_location,
-              namespace: "http://schemas.openxmlformats.org/officeDocument/2006/math",
-              prefix: "m",
-            ),
+          Lutaml::Model::GlobalRegister.register(Lutaml::Model::Register.new(register_id))
+          Lutaml::Model::Config.default_register = register_id
+
+          described_class.to_models(
+            Net::HTTP.get(URI("#{schema_location}/shared-math.xsd")),
+            location: schema_location,
+            namespace: "http://schemas.openxmlformats.org/officeDocument/2006/math",
+            module_namespace: "OOXML",
+            register_id: :ooxml,
+            output_dir: dir,
+            create_files: true,
           )
-          namespaced_classes
+          require File.join(dir, "ooxml_registry.rb")
+          OOXML.register_all
+        end
+
+        after do
+          Lutaml::Model::Config.default_register = :default
+          FileUtils.rm_rf(dir)
+          # Clean up dynamically generated register to prevent test pollution
+          Lutaml::Model::GlobalRegister.unregister(:ooxml) if Lutaml::Model::GlobalRegister.lookup(:ooxml)
+          Object.send(:remove_const, :OOXML) if defined?(OOXML)
         end
 
         let(:register_id) { :ooxml }
-        let(:loaded_classes) { {} }
-        let(:module_name) { "OOXML" }
+        let(:dir) { Dir.mktmpdir }
         let(:schema_location) { "https://raw.githubusercontent.com/t-yuki/ooxml-xsd/refs/heads/master" }
+
         let(:xml) do
           <<~XML
             <m:CT_F xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math">
@@ -291,31 +370,46 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
         end
 
         it "matches the expected class names of the schema" do
+          # Session 101 fixed namespace prefix issue for reused child elements
+          # Session 114 fixed performance with recursive import resolution
+          # Session 115 fixed circular requires with module namespacing and autoload
+          # register_all resolves all imports, so attributes are populated
           expect(defined?(OOXML::CTOMath)).to eq("constant")
-          # TODO: The error is not expected once the issue#359 is implemented.
-          expect(OOXML::CTOMath.instance_variable_get(:@attributes)).to be_empty
-          expect { OOXML::CTF.from_xml(xml) }.to raise_error(Lutaml::Model::IncorrectSequenceError) do |error|
-            expect(error.message).to match(/does not match the expected sequence/)
-          end
-          expect(OOXML::CTF.instance_variable_get(:@attributes)).not_to be_empty
+          expect(OOXML::CTOMath.attributes(:ooxml)).not_to be_empty
+          expect(OOXML::CTF.from_xml(xml).to_xml(prefix: "m")).to be_xml_equivalent_to(xml)
+          expect(OOXML::CTF.attributes(:ooxml)).not_to be_empty
         end
       end
 
       context "when classes are generated and loaded but files are not created for UnitsML-v0.9.19 schema" do
         before do
-          loaded_classes.merge!(
-            described_class.to_models(
-              Net::HTTP.get(URI(schema_url)),
-              namespace: "http://unitsml.nist.gov/unitsml-v0.9.19",
-            ),
+          Lutaml::Model::GlobalRegister.register(Lutaml::Model::Register.new(register_id))
+          Lutaml::Model::Config.default_register = register_id
+
+          described_class.to_models(
+            Net::HTTP.get(URI(schema_url)),
+            namespace: "http://unitsml.nist.gov/unitsml-v0.9.19",
+            module_namespace: "UnitsMLV0919",
+            register_id: :unitsmlv0919,
+            output_dir: dir,
+            create_files: true,
           )
-          namespaced_classes
+          require File.join(dir, "unitsmlv0919_registry.rb")
+          UnitsMLV0919.register_all
+        end
+
+        after do
+          Lutaml::Model::Config.default_register = :default
+          FileUtils.rm_rf(dir)
+          # Clean up dynamically generated register to prevent test pollution
+          Lutaml::Model::GlobalRegister.unregister(:unitsmlv0919) if Lutaml::Model::GlobalRegister.lookup(:unitsmlv0919)
+          Object.send(:remove_const, :UnitsMLV0919) if defined?(UnitsMLV0919)
         end
 
         let(:register_id) { :unitsmlv0919 }
-        let(:loaded_classes) { {} }
-        let(:module_name) { "UnitsMLV0919" }
+        let(:dir) { Dir.mktmpdir }
         let(:schema_url) { "https://raw.githubusercontent.com/unitsml/schemas/refs/heads/main/unitsml/unitsml-v0.9.19.xsd" }
+
         let(:xml) do
           <<~XML
             <UnitsMLType xmlns="http://unitsml.nist.gov/unitsml-v0.9.19">
@@ -336,7 +430,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
               <!-- Units -->
               <UnitSet>
                 <!-- Base unit: meter -->
-                <Unit xml:id="u1" timeStamp="2024-06-01T00:00:00+00:00" dimensionURL="http://unitsml.nist.gov/si/length">
+                <Unit xml:id="u1" timeStamp="2024-06-01T00:00:00Z" dimensionURL="http://unitsml.nist.gov/si/length">
                   <UnitSystem name="SI" type="SI_base"/>
                   <UnitName>meter</UnitName>
                   <UnitSymbol type="ASCII">m</UnitSymbol>
@@ -351,7 +445,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
                 </Unit>
 
                 <!-- Derived unit: meter per second -->
-                <Unit xml:id="u2" timeStamp="2024-06-01T00:00:00+00:00" dimensionURL="http://unitsml.nist.gov/si/speed">
+                <Unit xml:id="u2" timeStamp="2024-06-01T00:00:00Z" dimensionURL="http://unitsml.nist.gov/si/speed">
                   <UnitSystem name="SI" type="SI_derived"/>
                   <UnitName>meter per second</UnitName>
                   <UnitSymbol type="ASCII">m/s</UnitSymbol>
@@ -369,7 +463,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
                 </Unit>
 
                 <!-- Non-SI unit: kilometer per hour -->
-                <Unit xml:id="u3" timeStamp="2024-06-01T00:00:00+00:00" dimensionURL="http://unitsml.nist.gov/si/speed">
+                <Unit xml:id="u3" timeStamp="2024-06-01T00:00:00Z" dimensionURL="http://unitsml.nist.gov/si/speed">
                   <UnitSystem name="SI" type="non-SI_accepted"/>
                   <UnitName>kilometer per hour</UnitName>
                   <UnitSymbol type="ASCII">km/h</UnitSymbol>
@@ -437,30 +531,46 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
         end
 
         it "matches the converted xml with the expected xml with a short example" do
-          expect(UnitsMLV0919::UnitsMLType.from_xml(xml).to_xml).to be_equivalent_to(xml)
+          expect(UnitsMLV0919::UnitsMLType.from_xml(xml).to_xml).to be_xml_equivalent_to(xml)
         end
 
         it "matches the converted xml with the expected xml with a detailed example" do
-          expect(UnitsMLV0919::UnitsMLType.from_xml(detailed_xml).to_xml).to be_equivalent_to(detailed_xml)
+          actual = UnitsMLV0919::UnitsMLType.from_xml(detailed_xml).to_xml
+          expect(strip_xml_comments(actual)).to be_xml_equivalent_to(strip_xml_comments(detailed_xml))
         end
       end
 
       context "when classes are generated and loaded but files are not created for UnitsML-v1.0-csd03 schema" do
         before do
-          loaded_classes.merge!(
-            described_class.to_models(
-              Net::HTTP.get(
-                URI(schema_url),
-              ),
-            ),
+          Lutaml::Model::GlobalRegister.register(Lutaml::Model::Register.new(register_id))
+          Lutaml::Model::Config.default_register = register_id
+
+          described_class.to_models(
+            Net::HTTP.get(URI(schema_url)),
+            module_namespace: "UnitsMLV10CSD03",
+            register_id: :unitsml_v1_0_csd03,
+            output_dir: dir,
+            create_files: true,
           )
-          namespaced_classes
+          require File.join(dir, "unitsmlv10csd03_registry.rb")
+          UnitsMLV10CSD03.register_all
+        end
+
+        after do
+          Lutaml::Model::Config.default_register = :default
+          FileUtils.rm_rf(dir)
+          # Clean up dynamically generated register to prevent test pollution
+          Lutaml::Model::GlobalRegister.unregister(:unitsml_v1_0_csd03) if Lutaml::Model::GlobalRegister.lookup(:unitsml_v1_0_csd03)
+          if defined?(UnitsMLV10CSD03)
+            Object.send(:remove_const,
+                        :UnitsMLV10CSD03)
+          end
         end
 
         let(:register_id) { :unitsml_v1_0_csd03 }
-        let(:loaded_classes) { {} }
-        let(:module_name) { "UnitsMLV10CSD03" }
+        let(:dir) { Dir.mktmpdir }
         let(:schema_url) { "https://raw.githubusercontent.com/unitsml/schemas/refs/heads/main/unitsml/unitsml-v1.0-csd03.xsd" }
+
         let(:xml) do
           <<~XML
             <UnitsMLType>
@@ -484,7 +594,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
           <<~XML
             <UnitsMLType>
               <UnitSet>
-                <Unit xml:id="u_meter" timeStamp="2024-06-01T12:00:00+00:00" dimensionURL="http://unitsml.nist.gov/si/meter">
+                <Unit xml:id="u_meter" timeStamp="2024-06-01T12:00:00Z" dimensionURL="http://unitsml.nist.gov/si/meter">
                   <UnitSystem name="SI" type="SI_base"/>
                   <UnitName xml:lang="en">meter</UnitName>
                   <UnitSymbol type="ASCII">m</UnitSymbol>
@@ -497,7 +607,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
                   <UnitHistory>Defined as the distance light travels in vacuum in 1/299792458 seconds.</UnitHistory>
                   <UnitRemark>Commonly used in science and engineering.</UnitRemark>
                 </Unit>
-                <Unit xml:id="u_second" timeStamp="2024-06-01T12:00:00+00:00" dimensionURL="http://unitsml.nist.gov/si/second">
+                <Unit xml:id="u_second" timeStamp="2024-06-01T12:00:00Z" dimensionURL="http://unitsml.nist.gov/si/second">
                   <UnitSystem name="SI" type="SI_base"/>
                   <UnitName xml:lang="en">second</UnitName>
                   <UnitSymbol type="ASCII">s</UnitSymbol>
@@ -505,7 +615,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
                     <EnumeratedRootUnit unit="second"/>
                   </RootUnits>
                 </Unit>
-                <Unit xml:id="u_newton" timeStamp="2024-06-01T12:00:00+00:00" dimensionURL="http://unitsml.nist.gov/si/newton">
+                <Unit xml:id="u_newton" timeStamp="2024-06-01T12:00:00Z" dimensionURL="http://unitsml.nist.gov/si/newton">
                   <UnitSystem name="SI" type="SI_derived"/>
                   <UnitName xml:lang="en">newton</UnitName>
                   <UnitSymbol type="ASCII">N</UnitSymbol>
@@ -524,30 +634,45 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
         end
 
         it "matches the converted xml with the expected xml with a short example" do
-          expect(UnitsMLV10CSD03::UnitsMLType.from_xml(xml).to_xml).to be_equivalent_to(xml)
+          expect(UnitsMLV10CSD03::UnitsMLType.from_xml(xml).to_xml).to be_xml_equivalent_to(xml)
         end
 
         it "matches the converted xml with the expected xml with a detailed example" do
-          expect(UnitsMLV10CSD03::UnitsMLType.from_xml(detailed_xml).to_xml).to be_equivalent_to(detailed_xml)
+          expect(UnitsMLV10CSD03::UnitsMLType.from_xml(detailed_xml).to_xml).to be_xml_equivalent_to(detailed_xml)
         end
       end
 
       context "when classes are generated and loaded but files are not created for UnitsML-v1.0-csd04 schema" do
         before do
-          loaded_classes.merge!(
-            described_class.to_models(
-              Net::HTTP.get(
-                URI(schema_url),
-              ),
-            ),
+          Lutaml::Model::GlobalRegister.register(Lutaml::Model::Register.new(register_id))
+          Lutaml::Model::Config.default_register = register_id
+
+          described_class.to_models(
+            Net::HTTP.get(URI(schema_url)),
+            module_namespace: "UnitsMLV10CSD04",
+            register_id: :unitsml_v1_0_csd04,
+            output_dir: dir,
+            create_files: true,
           )
-          namespaced_classes
+          require File.join(dir, "unitsmlv10csd04_registry.rb")
+          UnitsMLV10CSD04.register_all
+        end
+
+        after do
+          Lutaml::Model::Config.default_register = :default
+          FileUtils.rm_rf(dir)
+          # Clean up dynamically generated register to prevent test pollution
+          Lutaml::Model::GlobalRegister.unregister(:unitsml_v1_0_csd04) if Lutaml::Model::GlobalRegister.lookup(:unitsml_v1_0_csd04)
+          if defined?(UnitsMLV10CSD04)
+            Object.send(:remove_const,
+                        :UnitsMLV10CSD04)
+          end
         end
 
         let(:register_id) { :unitsml_v1_0_csd04 }
-        let(:loaded_classes) { {} }
-        let(:module_name) { "UnitsMLV10CSD04" }
+        let(:dir) { Dir.mktmpdir }
         let(:schema_url) { "https://raw.githubusercontent.com/unitsml/schemas/refs/heads/main/unitsml/unitsml-v1.0-csd04.xsd" }
+
         let(:xml) do
           <<~XML
             <UnitsMLType>
@@ -571,7 +696,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
           <<~XML
             <UnitsMLType>
               <UnitSet>
-                <Unit xml:id="u_meter" timeStamp="2024-06-01T12:00:00+00:00" dimensionURL="http://unitsml.nist.gov/si/meter">
+                <Unit xml:id="u_meter" timeStamp="2024-06-01T12:00:00Z" dimensionURL="http://unitsml.nist.gov/si/meter">
                   <UnitSystem name="SI" type="SI_base"/>
                   <UnitName xml:lang="en">meter</UnitName>
                   <UnitSymbol type="ASCII">m</UnitSymbol>
@@ -584,7 +709,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
                   <UnitHistory>Defined as the distance light travels in vacuum in 1/299792458 seconds.</UnitHistory>
                   <UnitRemark>Commonly used in science and engineering.</UnitRemark>
                 </Unit>
-                <Unit xml:id="u_second" timeStamp="2024-06-01T12:00:00+00:00" dimensionURL="http://unitsml.nist.gov/si/second">
+                <Unit xml:id="u_second" timeStamp="2024-06-01T12:00:00Z" dimensionURL="http://unitsml.nist.gov/si/second">
                   <UnitSystem name="SI" type="SI_base"/>
                   <UnitName xml:lang="en">second</UnitName>
                   <UnitSymbol type="ASCII">s</UnitSymbol>
@@ -592,7 +717,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
                     <EnumeratedRootUnit unit="second"/>
                   </RootUnits>
                 </Unit>
-                <Unit xml:id="u_newton" timeStamp="2024-06-01T12:00:00+00:00" dimensionURL="http://unitsml.nist.gov/si/newton">
+                <Unit xml:id="u_newton" timeStamp="2024-06-01T12:00:00Z" dimensionURL="http://unitsml.nist.gov/si/newton">
                   <UnitSystem name="SI" type="SI_derived"/>
                   <UnitName xml:lang="en">newton</UnitName>
                   <UnitSymbol type="ASCII">N</UnitSymbol>
@@ -611,11 +736,11 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
         end
 
         it "matches the converted xml with the expected xml with a short example" do
-          expect(UnitsMLV10CSD04::UnitsMLType.from_xml(xml).to_xml).to be_equivalent_to(xml)
+          expect(UnitsMLV10CSD04::UnitsMLType.from_xml(xml).to_xml).to be_xml_equivalent_to(xml)
         end
 
         it "matches the converted xml with the expected xml with a detailed example" do
-          expect(UnitsMLV10CSD04::UnitsMLType.from_xml(detailed_xml).to_xml).to be_equivalent_to(detailed_xml)
+          expect(UnitsMLV10CSD04::UnitsMLType.from_xml(detailed_xml).to_xml).to be_xml_equivalent_to(detailed_xml)
         end
       end
     end

data/spec/lutaml/xml/schema/xsd/errors/error_context_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "../spec_helper"
+require "lutaml/xml/schema/xsd/errors/error_context"
+
+RSpec.describe Lutaml::Xml::Schema::Xsd::Errors::ErrorContext do
+  describe "#initialize" do
+    it "creates context with all attributes" do
+      context = described_class.new(
+        location: "/root/element",
+        namespace: "http://example.com",
+        expected_type: "xs:string",
+        actual_value: "123",
+      )
+
+      expect(context.location).to eq("/root/element")
+      expect(context.namespace).to eq("http://example.com")
+      expect(context.expected_type).to eq("xs:string")
+      expect(context.actual_value).to eq("123")
+    end
+
+    it "stores additional attributes" do
+      context = described_class.new(
+        location: "/root",
+        custom_field: "custom_value",
+      )
+
+      expect(context.additional).to eq({ custom_field: "custom_value" })
+    end
+  end
+
+  describe "#to_h" do
+    it "converts context to hash" do
+      context = described_class.new(
+        location: "/root/element",
+        namespace: "http://example.com",
+        expected_type: "xs:string",
+        actual_value: "123",
+      )
+
+      hash = context.to_h
+      expect(hash[:location]).to eq("/root/element")
+      expect(hash[:namespace]).to eq("http://example.com")
+      expect(hash[:expected_type]).to eq("xs:string")
+      expect(hash[:actual_value]).to eq("123")
+    end
+
+    it "includes additional attributes" do
+      context = described_class.new(
+        location: "/root",
+        custom: "value",
+      )
+
+      hash = context.to_h
+      expect(hash[:custom]).to eq("value")
+    end
+
+    it "omits nil values" do
+      context = described_class.new(location: "/root")
+
+      hash = context.to_h
+      expect(hash).to eq({ location: "/root" })
+    end
+  end
+end