lutaml-model 0.7.7 → 0.8.1

data/spec/lutaml/xml/mapping_spec.rb

@@ -0,0 +1,1147 @@
+require "spec_helper"
+
+require "lutaml/xml/adapter/ox_adapter"
+require "lutaml/xml/adapter/oga_adapter"
+require "lutaml/xml/adapter/rexml_adapter"
+require_relative "../../support/xml_mapping_namespaces"
+
+# Define a sample class for testing map content
+class Italic < Lutaml::Model::Serializable
+  attribute :text, Lutaml::Model::Type::String, collection: true
+
+  xml do
+    element "i"
+    map_content to: :text
+  end
+end
+
+# Define a sample class for testing p tag
+class Paragraph < Lutaml::Model::Serializable
+  attribute :text, Lutaml::Model::Type::String
+  attribute :paragraph, Paragraph
+
+  xml do
+    element "p"
+
+    map_content to: :text
+    map_element "p", to: :paragraph
+  end
+end
+
+# Custom type for alpha attribute with Example namespace
+class ExampleAlphaType < Lutaml::Model::Type::String
+  xml do
+    namespace ExampleNamespace
+  end
+end
+
+module XmlMappingSpec
+  # Model for testing render_empty passthrough on map_attribute
+  class RenderEmptyAttributeModel < Lutaml::Model::Serializable
+    attribute :tags, :string, collection: true, initialize_empty: true
+
+    xml do
+      element "render-empty-attr"
+      map_attribute "tags", to: :tags, render_empty: true
+    end
+  end
+
+  # Child models for different namespaces
+  class ElementNilNamespaceChild < Lutaml::Model::Serializable
+    attribute :value, :string
+
+    xml do
+      element "ElementNilNamespace"
+      namespace :blank # Explicitly in blank namespace
+      map_content to: :value
+    end
+  end
+
+  class ElementNewNamespaceChild < Lutaml::Model::Serializable
+    attribute :value, :string
+
+    xml do
+      element "ElementNewNamespace"
+      namespace XmiNewNamespace
+      map_content to: :value
+    end
+  end
+
+  class ChildNamespaceNil < Lutaml::Model::Serializable
+    attribute :element_default_namespace, :string
+    attribute :element_nil_namespace, ElementNilNamespaceChild
+    attribute :element_new_namespace, ElementNewNamespaceChild
+
+    xml do
+      element "ChildNamespaceNil"
+      namespace XmiNamespace
+
+      # this will inherit the namespace from the parent i.e <xmi:ElementDefaultNamespace>
+      map_element "ElementDefaultNamespace", to: :element_default_namespace
+      # this will have nil namespace applied via child model
+      map_element "ElementNilNamespace", to: :element_nil_namespace
+      # this will have new namespace via child model
+      map_element "ElementNewNamespace", to: :element_new_namespace
+    end
+  end
+
+  class Address < Lutaml::Model::Serializable
+    attribute :street, ::Lutaml::Model::Type::String, raw: true
+    attribute :city, :string, raw: true
+    attribute :text, :string
+    attribute :address, Address
+
+    xml do
+      element "address"
+
+      map_element "street", to: :street
+      map_element "city", to: :city
+      map_element "text", to: :text
+    end
+  end
+
+  class Person < Lutaml::Model::Serializable
+    attribute :name, Lutaml::Model::Type::String
+    attribute :address, XmlMappingSpec::Address
+  end
+
+  class Mfenced < Lutaml::Model::Serializable
+    attribute :open, :string
+
+    xml do
+      element "mfenced"
+      map_attribute "open", to: :open
+    end
+  end
+
+  class MmlMath < Lutaml::Model::Serializable
+    attribute :mfenced, Mfenced
+
+    xml do
+      element "math"
+      namespace MathMlNamespace
+      map_element :mfenced, to: :mfenced
+    end
+  end
+
+  # Custom type for alpha attribute with Example namespace
+  class ExampleAlphaType < Lutaml::Model::Type::String
+    xml do
+      namespace ExampleNamespace
+    end
+  end
+
+  class AttributeNamespace < Lutaml::Model::Serializable
+    attribute :alpha, ExampleAlphaType
+    attribute :beta, :string
+
+    xml do
+      element "example"
+      namespace CheckNamespace
+
+      map_attribute "alpha", to: :alpha
+      map_attribute "beta", to: :beta
+    end
+  end
+
+  # Child models for same element name with different namespaces
+  class GmlApplicationSchema < Lutaml::Model::Serializable
+    attribute :value, :string
+
+    xml do
+      element "ApplicationSchema"
+      namespace GmlNamespace
+      map_content to: :value
+    end
+  end
+
+  class CityGmlApplicationSchema < Lutaml::Model::Serializable
+    attribute :value, :string
+
+    xml do
+      element "ApplicationSchema"
+      namespace CityGmlNamespace
+      map_content to: :value
+    end
+  end
+
+  class SameNameDifferentNamespace < Lutaml::Model::Serializable
+    attribute :gml_application_schema, GmlApplicationSchema
+    attribute :citygml_application_schema, CityGmlApplicationSchema
+    attribute :application_schema, :string
+    attribute :app, :string
+
+    xml do
+      element "SameElementName"
+      namespace XmiNamespace
+
+      map_element "ApplicationSchema", to: :gml_application_schema
+      map_element "ApplicationSchema", to: :citygml_application_schema
+      map_element "ApplicationSchema", to: :application_schema
+      map_attribute "App", to: :app
+    end
+  end
+
+  class OverrideDefaultNamespacePrefix < Lutaml::Model::Serializable
+    attribute :same_element_name, SameNameDifferentNamespace
+
+    xml do
+      element "OverrideDefaultNamespacePrefix"
+      # SameNameDifferentNamespace already has XmiNamespace, no override needed
+      map_element :SameElementName, to: :same_element_name
+    end
+  end
+
+  # Custom type for xmi:idref attribute
+  class XmiIdrefType < Lutaml::Model::Type::String
+    xml do
+      namespace XmiNamespace
+    end
+  end
+
+  # Child model for element with TestElement namespace
+  class TestElement < Lutaml::Model::Serializable
+    attribute :value, :string
+
+    xml do
+      element "element"
+      namespace TestElementNamespace
+      map_content to: :value
+    end
+  end
+
+  # Wrapper for annotated element without namespace
+  class AnnotatedElementNoNs < Lutaml::Model::Serializable
+    attribute :idref, XmiIdrefType
+
+    xml do
+      element "annotatedElement"
+      # No namespace declaration - blank namespace element
+      map_attribute "idref", to: :idref
+    end
+  end
+
+  class OwnedComment < Lutaml::Model::Serializable
+    attribute :annotated_attribute, :string
+    attribute :annotated_element, AnnotatedElementNoNs
+
+    xml do
+      element "ownedComment"
+      map_attribute "annotatedElement", to: :annotated_attribute
+      map_element "annotatedElement", to: :annotated_element
+    end
+  end
+
+  class Date < Lutaml::Model::Serializable
+    attribute :type, :string
+    attribute :text, :string
+    attribute :content, :string
+    attribute :from, :string
+    attribute :to, :string
+    attribute :on, :string
+
+    xml do
+      element "date"
+      mixed_content
+      map_attribute "type", to: :type
+      map_attribute "text", to: :text
+      map_element "from", to: :from
+      map_element "to", to: :to
+      map_element "on", to: :on
+    end
+  end
+
+  # Child models for element-level namespace test
+  class ChildNamespaceElement < Lutaml::Model::Serializable
+    attribute :value, :string
+
+    xml do
+      element "WithNamespace"
+      namespace ChildNamespace
+      map_content to: :value
+    end
+  end
+
+  class WithoutNamespaceElement < Lutaml::Model::Serializable
+    attribute :value, :string
+
+    xml do
+      element "WithoutNamespace"
+      # No namespace - blank namespace
+      map_content to: :value
+    end
+  end
+
+  class WithChildExplicitNamespace < Lutaml::Model::Serializable
+    attribute :with_default_namespace, :string
+    attribute :with_namespace, ChildNamespaceElement
+    attribute :without_namespace, WithoutNamespaceElement
+
+    xml do
+      element "WithChildExplicitNamespaceNil"
+      namespace ParentNamespace
+
+      map_element "DefaultNamespace", to: :with_default_namespace
+      map_element "WithNamespace", to: :with_namespace
+      map_element "WithoutNamespace", to: :without_namespace
+    end
+  end
+
+  class SchemaLocationOrdered < Lutaml::Model::Serializable
+    attribute :content, :string, collection: true
+    attribute :second, SchemaLocationOrdered
+
+    xml do
+      element "schemaLocationOrdered"
+      mixed_content
+
+      map_content to: :content
+      map_element "schemaLocationOrdered", to: :second
+    end
+  end
+
+  class Documentation < Lutaml::Model::Serializable
+    attribute :content, :string, collection: true
+
+    xml do
+      element "documentation"
+      mixed_content
+      namespace XsdNamespace
+
+      map_content to: :content
+    end
+  end
+
+  class Schema < Lutaml::Model::Serializable
+    attribute :documentation, Documentation, collection: true
+
+    xml do
+      element "schema"
+      namespace XsdNamespace
+
+      map_element :documentation, to: :documentation
+    end
+  end
+
+  class TitleCollection < Lutaml::Model::Collection
+    instances :items, :string
+
+    xml do
+      element "titles"
+      map_attribute "title", to: :items, as_list: {
+        import: ->(str) { str.split("; ") },
+        export: ->(arr) { arr.join("; ") },
+      }
+    end
+  end
+
+  class TitleDelimiterCollection < Lutaml::Model::Collection
+    instances :items, :string
+
+    xml do
+      element "titles"
+      map_attribute "title", to: :items, delimiter: "; "
+    end
+  end
+
+  class ToBeDuplicated < Lutaml::Model::Serializable
+    attribute :content, :string
+    attribute :element, TestElement
+    attribute :attribute, :string
+
+    xml do
+      element "ToBeDuplicated"
+      namespace TestingDuplicateNamespace
+
+      map_content to: :content
+      map_attribute "attribute", to: :attribute
+      map_element "element", to: :element
+    end
+  end
+
+  class SpecialCharContentWithMapAll < Lutaml::Model::Serializable
+    attribute :all_content, :string
+
+    xml do
+      element "SpecialCharContentWithMapAll"
+
+      map_all to: :all_content
+    end
+  end
+
+  class MapAllWithCustomMethod < Lutaml::Model::Serializable
+    attribute :all_content, :string
+
+    xml do
+      element "MapAllWithCustomMethod"
+
+      map_all to: :all_content,
+              with: { to: :content_to_xml, from: :content_from_xml }
+    end
+
+    def content_to_xml(model, parent, doc)
+      content = model.all_content.sub(/^<div>/, "").sub(/<\/div>$/, "")
+      doc.add_xml_fragment(parent, content)
+    end
+
+    def content_from_xml(model, value)
+      model.all_content = "<div>#{value}</div>"
+    end
+  end
+
+  class WithMapAll < Lutaml::Model::Serializable
+    attribute :all_content, :string
+    attribute :attr, :string
+
+    xml do
+      element "WithMapAll"
+
+      map_all to: :all_content
+    end
+  end
+
+  class WithoutMapAll < Lutaml::Model::Serializable
+    attribute :content, :string
+
+    xml do
+      element "WithoutMapAll"
+
+      map_content to: :content
+    end
+  end
+
+  class WithNestedMapAll < Lutaml::Model::Serializable
+    attribute :age, :integer
+    attribute :name, :string
+    attribute :description, WithMapAll
+
+    xml do
+      element "WithNestedMapAll"
+
+      map_attribute :age, to: :age
+      map_element :name, to: :name
+      map_element :description, to: :description
+    end
+  end
+end
+
+RSpec.describe Lutaml::Xml::Mapping do
+  describe "as_list feature for XML attributes" do
+    let(:xml) { '<titles title="Title One; Title Two; Title Three"/>' }
+
+    it "imports delimited attribute to array" do
+      collection = XmlMappingSpec::TitleCollection.from_xml(xml)
+      expect(collection.items).to eq(["Title One", "Title Two", "Title Three"])
+    end
+
+    it "round-trips correctly" do
+      collection = XmlMappingSpec::TitleCollection.from_xml(xml)
+      generated_xml = collection.to_xml
+      expect(generated_xml).to be_xml_equivalent_to(xml)
+    end
+  end
+
+  describe "delimiter feature for XML attributes" do
+    let(:xml) { '<titles title="Title One; Title Two; Title Three"/>' }
+
+    it "imports delimited attribute to array" do
+      collection = XmlMappingSpec::TitleDelimiterCollection.from_xml(xml)
+      expect(collection.items).to eq(["Title One", "Title Two", "Title Three"])
+    end
+
+    it "round-trips delimited attribute correctly" do
+      collection = XmlMappingSpec::TitleDelimiterCollection.from_xml(xml)
+      generated_xml = collection.to_xml
+      expect(generated_xml).to be_xml_equivalent_to(xml)
+    end
+  end
+
+  describe "find_by_to! error handling" do
+    it "raises NoMappingFoundError when mapping is missing in xml mapping" do
+      mapping = described_class.new
+      expect do
+        mapping.find_by_to!("nonexistent")
+      end.to raise_error(Lutaml::Model::NoMappingFoundError,
+                         /No mapping available for `nonexistent`/)
+    end
+  end
+
+  shared_examples "having XML Mappings" do |adapter_class|
+    around do |example|
+      old_adapter = Lutaml::Model::Config.xml_adapter
+      Lutaml::Model::Config.xml_adapter = adapter_class
+
+      example.run
+    ensure
+      Lutaml::Model::Config.xml_adapter = old_adapter
+    end
+
+    # rubocop:disable all
+    let(:mapping) { Lutaml::Xml::Mapping.new }
+    # rubocop:enable all
+
+    context "with attribute having namespace" do
+      let(:input_xml) do
+        <<~XML
+          <example xmlns="http://www.check.com"
+                   ex1:alpha="hello"
+                   beta="bye"
+                   xmlns:ex1="http://www.example.com">
+          </example>
+        XML
+      end
+
+      it "checks the attribute with and without namespace" do
+        parsed = XmlMappingSpec::AttributeNamespace.from_xml(input_xml)
+
+        expect(parsed.alpha).to eq("hello")
+        expect(parsed.beta).to eq("bye")
+
+        # Ox adapter omits xmlns:ex1 declaration (namespace hoisting difference)
+        expected = if adapter_class == Lutaml::Xml::Adapter::OxAdapter
+                     <<~XML
+                       <example xmlns="http://www.check.com" ex1:alpha="hello" beta="bye"/>
+                     XML
+                   else
+                     input_xml
+                   end
+        expect(parsed.to_xml).to be_xml_equivalent_to(expected)
+      end
+    end
+
+    context "with explicit namespace" do
+      let(:mml) do
+        <<~XML
+          <math xmlns="http://www.w3.org/1998/Math/MathML">
+            <mfenced open="("></mfenced>
+          </math>
+        XML
+      end
+
+      let(:mml_nokogiri) do
+        <<~XML
+          <math xmlns="http://www.w3.org/1998/Math/MathML">
+            <mfenced open="("></mfenced>
+          </math>
+        XML
+      end
+
+      it "nil namespace" do
+        parsed = XmlMappingSpec::MmlMath.from_xml(mml)
+        # When parent has element_form_default :qualified (MathMlNamespace has this),
+        # children without explicit namespace inherit parent's namespace.
+        # No xmlns="" needed because inheritance is automatic.
+        expect(parsed.to_xml).to be_xml_equivalent_to(mml_nokogiri)
+      end
+    end
+
+    # The current implementation hoists namespace declarations to parent elements
+    # for efficiency. This is W3C compliant. Tests updated to expect hoisted format.
+    context "when overriding child namespace prefix" do
+      let(:input_xml) do
+        <<~XML
+          <OverrideDefaultNamespacePrefix>
+            <SameElementName xmlns="http://www.omg.org/spec/XMI/20131001" App="hello">
+              <GML:ApplicationSchema xmlns="" xmlns:GML="http://www.sparxsystems.com/profiles/GML/1.0">GML App</GML:ApplicationSchema>
+              <CityGML:ApplicationSchema xmlns="" xmlns:CityGML="http://www.sparxsystems.com/profiles/CityGML/1.0">CityGML App</CityGML:ApplicationSchema>
+              <ApplicationSchema>App</ApplicationSchema>
+            </SameElementName>
+          </OverrideDefaultNamespacePrefix>
+        XML
+      end
+
+      # Expected output with format preservation
+      # CityGML preserves PREFIX format (format info available in input_formats)
+      # GML falls back to DEFAULT format due to namespace_locations collision
+      # (same-name sibling elements overwrite each other's location data)
+      let(:expected_xml) do
+        <<~XML
+          <OverrideDefaultNamespacePrefix>
+            <SameElementName xmlns="http://www.omg.org/spec/XMI/20131001" App="hello">
+              <ApplicationSchema xmlns="http://www.sparxsystems.com/profiles/GML/1.0">GML App</ApplicationSchema>
+              <CityGML:ApplicationSchema xmlns:CityGML="http://www.sparxsystems.com/profiles/CityGML/1.0">CityGML App</CityGML:ApplicationSchema>
+              <ApplicationSchema>App</ApplicationSchema>
+            </SameElementName>
+          </OverrideDefaultNamespacePrefix>
+        XML
+      end
+
+      it "expect to round-trips" do
+        parsed = XmlMappingSpec::OverrideDefaultNamespacePrefix.from_xml(input_xml)
+        # expected_xml already handles adapter-specific behavior
+        expect(parsed.to_xml).to be_xml_equivalent_to(expected_xml)
+      end
+    end
+
+    # The current implementation hoists namespace declarations to parent elements
+    # for efficiency. This is W3C compliant. Tests updated to expect hoisted format.
+    context "with same element and attribute name" do
+      let(:xml_with_element) do
+        <<~XML
+          <ownedComment>
+            <annotatedElement xmi:idref="ABC" xmlns:xmi="http://www.omg.org/spec/XMI/20131001" />
+          </ownedComment>
+        XML
+      end
+
+      # Expected output with namespace hoisting
+      let(:xml_with_element_hoisted) do
+        <<~XML
+          <ownedComment xmlns:xmi="http://www.omg.org/spec/XMI/20131001">
+            <annotatedElement xmi:idref="ABC" />
+          </ownedComment>
+        XML
+      end
+
+      let(:xml_with_attribute) do
+        <<~XML
+          <ownedComment annotatedElement="test2">
+          </ownedComment>
+        XML
+      end
+
+      let(:xml_with_same_name_attribute_and_element) do
+        <<~XML
+          <ownedComment annotatedElement="test2">
+            <annotatedElement xmi:idref="ABC" xmlns:xmi="http://www.omg.org/spec/XMI/20131001" />
+          </ownedComment>
+        XML
+      end
+
+      # Expected output with namespace hoisting
+      let(:xml_with_same_name_attribute_and_element_hoisted) do
+        <<~XML
+          <ownedComment xmlns:xmi="http://www.omg.org/spec/XMI/20131001" annotatedElement="test2">
+            <annotatedElement xmi:idref="ABC" />
+          </ownedComment>
+        XML
+      end
+
+      let(:xml) do
+        "<date type=\"published\"> End of December \n  <on>2020-01</on> Start of January \n</date>\n"
+      end
+
+      it "parse and serializes the input xml correctly # lutaml/issues/217" do
+        parsed = XmlMappingSpec::OwnedComment.from_xml(xml_with_element)
+        serialized = parsed.to_xml
+
+        # Different adapters have different hoisting behaviors:
+        # - Nokogiri/Oga: Hoists namespace to parent
+        # - Ox: No namespace declaration (uses inline xmi prefix without xmlns)
+        expected = if adapter_class == Lutaml::Xml::Adapter::OxAdapter
+                     # Ox doesn't add xmlns declaration when model has no namespace
+                     <<~XML.strip
+                       <ownedComment>
+                         <annotatedElement xmi:idref="ABC" />
+                       </ownedComment>
+                     XML
+                   else
+                     # Nokogiri/Oga hoist the namespace
+                     xml_with_element_hoisted.strip
+                   end
+        expect(serialized).to be_xml_equivalent_to(expected)
+      end
+
+      it "parse and serialize model correctly" do
+        parsed = XmlMappingSpec::OwnedComment.from_xml(xml_with_attribute)
+
+        serialized = parsed.to_xml
+
+        expect(serialized).to be_xml_equivalent_to(xml_with_attribute)
+      end
+
+      it "parse and serialize model correctly with both attribute and element" do
+        parsed = XmlMappingSpec::OwnedComment.from_xml(xml_with_same_name_attribute_and_element)
+        serialized = parsed.to_xml
+
+        # Different adapters have different hoisting behaviors:
+        # - Nokogiri/Oga: Hoists namespace to parent
+        # - Ox: No namespace declaration (uses inline xmi prefix without xmlns)
+        expected = if adapter_class == Lutaml::Xml::Adapter::OxAdapter
+                     # Ox doesn't add xmlns declaration when model has no namespace
+                     <<~XML.strip
+                       <ownedComment annotatedElement="test2">
+                         <annotatedElement xmi:idref="ABC" />
+                       </ownedComment>
+                     XML
+                   else
+                     # Nokogiri/Oga hoist the namespace
+                     xml_with_same_name_attribute_and_element_hoisted
+                   end
+        expect(serialized).to be_xml_equivalent_to(expected)
+      end
+
+      it "testing parse element" do
+        parsed = XmlMappingSpec::Date.from_xml(xml)
+        serialized = parsed.to_xml
+
+        expect(serialized).to be_xml_equivalent_to(xml)
+      end
+    end
+
+    # The current implementation uses default namespace format instead of prefix format
+    # for child elements with different namespaces. Both are W3C compliant.
+    context "with same name elements" do
+      let(:input_xml) do
+        <<~XML
+          <SameElementName xmlns="http://www.omg.org/spec/XMI/20131001" App="hello">
+            <GML:ApplicationSchema xmlns="" xmlns:GML="http://www.sparxsystems.com/profiles/GML/1.0">GML App</GML:ApplicationSchema>
+            <CityGML:ApplicationSchema xmlns="" xmlns:CityGML="http://www.sparxsystems.com/profiles/CityGML/1.0">CityGML App</CityGML:ApplicationSchema>
+            <ApplicationSchema>App</ApplicationSchema>
+          </SameElementName>
+        XML
+      end
+
+      # Expected output: CityGML preserves PREFIX format (format info preserved in input_formats)
+      # GML uses DEFAULT format (format info lost due to namespace_locations sibling collision)
+      # Note: Ox adapter always uses prefix format
+      let(:expected_xml) do
+        if adapter_class == Lutaml::Xml::Adapter::OxAdapter
+          # Ox uses prefix format
+          <<~XML
+            <SameElementName App="hello" xmlns="http://www.omg.org/spec/XMI/20131001">
+              <GML:ApplicationSchema xmlns:GML="http://www.sparxsystems.com/profiles/GML/1.0">GML App</GML:ApplicationSchema>
+              <CityGML:ApplicationSchema xmlns:CityGML="http://www.sparxsystems.com/profiles/CityGML/1.0">CityGML App</CityGML:ApplicationSchema>
+              <ApplicationSchema>App</ApplicationSchema>
+            </SameElementName>
+          XML
+        else
+          # Nokogiri/Oga: CityGML preserves PREFIX format, GML uses DEFAULT
+          <<~XML
+            <SameElementName xmlns="http://www.omg.org/spec/XMI/20131001" App="hello">
+              <ApplicationSchema xmlns="http://www.sparxsystems.com/profiles/GML/1.0">GML App</ApplicationSchema>
+              <CityGML:ApplicationSchema xmlns:CityGML="http://www.sparxsystems.com/profiles/CityGML/1.0">CityGML App</CityGML:ApplicationSchema>
+              <ApplicationSchema>App</ApplicationSchema>
+            </SameElementName>
+          XML
+        end
+      end
+
+      let(:expected_order) do
+        create_pattern_mapping([
+                                 ["Element",
+                                  "ApplicationSchema"],
+                                 ["Element",
+                                  "ApplicationSchema"],
+                                 ["Element",
+                                  "ApplicationSchema"],
+                               ])
+      end
+
+      let(:parsed) do
+        XmlMappingSpec::SameNameDifferentNamespace.from_xml(input_xml)
+      end
+
+      def create_pattern_mapping(array)
+        array.map do |type, text|
+          Lutaml::Xml::Element.new(type, text)
+        end
+      end
+
+      it "citygml_application_schema should be correct" do
+        expect(parsed.citygml_application_schema.value).to eq("CityGML App")
+      end
+
+      it "gml_application_schema should be correct" do
+        expect(parsed.gml_application_schema.value).to eq("GML App")
+      end
+
+      it "application_schema should be correct" do
+        expect(parsed.application_schema).to eq("App")
+      end
+
+      it "app should be correct" do
+        expect(parsed.app).to eq("hello")
+      end
+
+      it "element_order should be correct" do
+        expect(parsed.element_order).to eq(expected_order)
+      end
+
+      it "element_order omits whitespace-only text nodes" do
+        # Moxml's Nokogiri adapter filters whitespace-only text nodes between
+        # elements, matching the behavior of Oga/Ox/Rexml adapters. This test
+        # locks in that behavior so a regression is detected if moxml changes.
+        text_entries = parsed.element_order.select { |e| e.type == "Text" }
+        expect(text_entries).to be_empty
+      end
+
+      it "to_xml should be correct" do
+        # Expect default namespace format instead of prefix format
+        expect(parsed.to_xml).to be_xml_equivalent_to(expected_xml)
+      end
+    end
+
+    context "with child having explicit namespaces" do
+      let(:xml) do
+        <<~XML.strip
+          <WithChildExplicitNamespaceNil xmlns="http://parent-namespace">
+            <DefaultNamespace xmlns="">default namespace text</DefaultNamespace>
+            <cn:WithNamespace xmlns="" xmlns:cn="http://child-namespace">explicit namespace text</cn:WithNamespace>
+            <pn:WithoutNamespace>without namespace text</pn:WithoutNamespace>
+          </WithChildExplicitNamespaceNil>
+        XML
+      end
+
+      let(:parsed) do
+        XmlMappingSpec::WithChildExplicitNamespace.from_xml(xml)
+      end
+
+      it "reads element with default namespace" do
+        expect(parsed.with_default_namespace).to eq("default namespace text")
+      end
+
+      it "reads element with explicit namespace" do
+        expect(parsed.with_namespace.value).to eq("explicit namespace text")
+      end
+
+      it "reads element without namespace" do
+        # NOTE: mapping with namespace: nil, prefix: nil has differing adapter behavior:
+        # - Nokogiri: Cannot parse element with parent namespace prefix, returns nil
+        # - Ox/Oga: Can parse element with parent namespace prefix successfully
+        if adapter_class == Lutaml::Xml::Adapter::NokogiriAdapter
+          expect(parsed.without_namespace).to be_nil
+        else
+          expect(parsed.without_namespace.value).to eq("without namespace text")
+        end
+      end
+
+      it "round-trips xml with child explicit namespace" do
+        # Serialize the parsed model
+        serialized = parsed.to_xml
+
+        if adapter_class == Lutaml::Xml::Adapter::NokogiriAdapter
+          # Nokogiri cannot parse the pn:WithoutNamespace element, so it's nil
+          # and won't be in the serialized output. Verify other elements round-trip.
+          reparsed = XmlMappingSpec::WithChildExplicitNamespace.from_xml(serialized)
+          expect(reparsed.with_default_namespace).to eq("default namespace text")
+          expect(reparsed.with_namespace.value).to eq("explicit namespace text")
+        else
+          # Ox/Oga can parse the element successfully
+          # When parent has element_form_default: :qualified (ParentNamespace has this),
+          # children without explicit namespace inherit parent's namespace.
+          # WithoutNamespaceElement has no namespace declaration, so it inherits.
+          # Round-trip fidelity: child elements preserve the prefix format from input
+          # cn:WithNamespace uses PREFIX format to preserve parent's default namespace context
+          expected_xml = <<~XML.strip
+            <WithChildExplicitNamespaceNil xmlns="http://parent-namespace">
+              <DefaultNamespace>default namespace text</DefaultNamespace>
+              <cn:WithNamespace xmlns:cn="http://child-namespace">explicit namespace text</cn:WithNamespace>
+              <WithoutNamespace>without namespace text</WithoutNamespace>
+            </WithChildExplicitNamespaceNil>
+          XML
+          expect(serialized).to be_xml_equivalent_to(expected_xml)
+        end
+      end
+    end
+
+    context "with default namespace" do
+      before do
+        mapping.root("ceramic")
+        mapping.namespace(CeramicNamespace)
+        mapping.map_element("type", to: :type)
+        mapping.map_element("color", to: :color, delegate: :glaze)
+        mapping.map_element("finish", to: :finish, delegate: :glaze)
+      end
+
+      it "sets the default namespace for the root element" do
+        expect(mapping.namespace_uri).to eq("https://example.com/ceramic/1.2")
+        expect(mapping.namespace_prefix).to eq("cer")
+      end
+
+      it "maps elements correctly" do
+        expect(mapping.elements.size).to eq(3)
+        expect(mapping.elements[0].name).to eq("type")
+        expect(mapping.elements[1].delegate).to eq(:glaze)
+      end
+    end
+
+    context "with prefixed namespace" do
+      before do
+        mapping.root("ceramic")
+        mapping.namespace(CeramicNamespace)
+        mapping.map_element("type", to: :type)
+        mapping.map_element("color", to: :color, delegate: :glaze)
+        mapping.map_element("finish", to: :finish, delegate: :glaze)
+      end
+
+      it "sets the namespace with prefix for the root element" do
+        expect(mapping.namespace_uri).to eq("https://example.com/ceramic/1.2")
+        expect(mapping.namespace_prefix).to eq("cer")
+      end
+
+      it "maps elements correctly" do
+        expect(mapping.elements.size).to eq(3)
+        expect(mapping.elements[0].name).to eq("type")
+        expect(mapping.elements[1].delegate).to eq(:glaze)
+      end
+    end
+
+    context "with element-level namespace" do
+      # NOTE: Version 0.9.0 removed namespace: parameter on map_element
+      # Namespaces must be declared at model class level, not mapping level
+      # See: docs/_migrations/0-9-0-namespace-api-migration.adoc
+      it "raises error for deprecated namespace parameter on map_element" do
+        expect do
+          mapping.map_element(
+            "type",
+            to: :type,
+            namespace: CeramicNamespace,
+          )
+        end.to raise_error(Lutaml::Model::IncorrectMappingArgumentsError,
+                           /namespace is not allowed at element mapping level/)
+      end
+    end
+
+    context "with attribute-level namespace" do
+      # NOTE: Version 0.9.0 removed namespace: parameter on map_attribute
+      # Namespaces must be declared at model class level (for elements) or
+      # using type namespaces (for attributes)
+      # See: docs/_migrations/0-9-0-namespace-api-migration.adoc
+      it "raises error for deprecated namespace parameter on map_attribute" do
+        expect do
+          mapping.map_attribute(
+            "date",
+            to: :date,
+            namespace: CeramicNamespace,
+          )
+        end.to raise_error(Lutaml::Model::IncorrectMappingArgumentsError,
+                           /namespace is not allowed at attribute mapping level/)
+      end
+    end
+
+    context "with nil element-level namespace" do
+      # instead of prefix format for child elements with different namespaces.
+      # Both are W3C compliant.
+      let(:expected_xml) do
+        # Ox uses prefix format, Nokogiri/Oga use default format
+        if adapter_class == Lutaml::Xml::Adapter::OxAdapter
+          <<~XML
+            <ChildNamespaceNil xmlns="http://www.omg.org/spec/XMI/20131001">
+              <ElementDefaultNamespace>Default namespace</ElementDefaultNamespace>
+              <ElementNilNamespace xmlns="">No namespace</ElementNilNamespace>
+              <new:ElementNewNamespace xmlns:new="http://www.omg.org/spec/XMI/20161001">New namespace</new:ElementNewNamespace>
+            </ChildNamespaceNil>
+          XML
+        else
+          <<~XML
+            <ChildNamespaceNil xmlns="http://www.omg.org/spec/XMI/20131001">
+              <ElementDefaultNamespace>Default namespace</ElementDefaultNamespace>
+              <ElementNilNamespace xmlns="">No namespace</ElementNilNamespace>
+              <ElementNewNamespace xmlns="http://www.omg.org/spec/XMI/20161001">New namespace</ElementNewNamespace>
+            </ChildNamespaceNil>
+          XML
+        end
+      end
+
+      let(:model) do
+        XmlMappingSpec::ChildNamespaceNil.new(
+          {
+            element_default_namespace: "Default namespace",
+            element_nil_namespace: XmlMappingSpec::ElementNilNamespaceChild.new(value: "No namespace"),
+            element_new_namespace: XmlMappingSpec::ElementNewNamespaceChild.new(value: "New namespace"),
+          },
+        )
+      end
+
+      it "expect to apply correct namespaces" do
+        expect(model.to_xml).to be_xml_equivalent_to(expected_xml)
+      end
+    end
+
+    context "with schemaLocation" do
+      context "when no mixed_content" do
+        let(:xml) do
+          '<p xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/gml/3.2 http://schemas.opengis.net/gml/3.2.1/gml.xsd"><p xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/gml/3.7"> Some text inside paragraph </p></p>'
+        end
+
+        it "contain schemaLocation attributes" do
+          expect(Paragraph.from_xml(xml).to_xml).to be_xml_equivalent_to(xml)
+        end
+
+        it "prints warning if defined explicitly in class" do
+          error_regex = /\[Lutaml::Model\] WARN: `schemaLocation` is handled by default\. No need to explicitly define at `mapping_spec.rb:\d+`/
+
+          expect do
+            mapping.map_attribute("schemaLocation", to: :schema_location)
+          end.to output(error_regex).to_stderr
+        end
+      end
+
+      context "when mixed content is true and child is content_mapping" do
+        let(:map_all_error) { "map_all is not allowed with other mappings" }
+        let(:invalid_element) { "must be defined without namespace" }
+        let(:mfenced) do
+          <<~XML
+            <mfenced xmlns="#{XmiNewNamespace}">Str<sub>3</sub>text<sup>1</sup>1</mfenced>
+              #{map_all}
+          XML
+        end
+
+        let(:generated_xml) do
+          XmlMappingSpec::Schema.from_xml(xml).to_xml
+        end
+        let(:xml) do
+          <<~XML
+            <schema xmlns="http://www.w3.org/2001/XMLSchema">
+              <documentation>asdf</documentation>
+            </schema>
+          XML
+        end
+
+        it "raises error when map_all used in content_mapping without custom methods" do
+          original_mapping = XmlMappingSpec::MmlMath.mappings[:xml].deep_dup
+
+          begin
+            expect do
+              XmlMappingSpec::MmlMath.xml do
+                map_element "mfenced", to: :built_in_mfenced
+              end
+              XmlMappingSpec::MmlMath.xml do
+                map_all to: :all_content
+              end
+            end.to raise_error(StandardError, map_all_error)
+          ensure
+            XmlMappingSpec::MmlMath.instance_variable_set(:@mappings,
+                                                          { xml: original_mapping })
+            Lutaml::Model::TransformationRegistry.instance.clear
+          end
+        end
+
+        it "can be defined after any other mapping" do
+          original_mapping = XmlMappingSpec::MmlMath.mappings[:xml].deep_dup
+
+          begin
+            expect do
+              XmlMappingSpec::MmlMath.xml do
+                map_all to: :all_content
+                namespace XmiNewNamespace
+              end
+            end.to raise_error(StandardError, map_all_error)
+          ensure
+            XmlMappingSpec::MmlMath.instance_variable_set(:@mappings,
+                                                          { xml: original_mapping })
+            Lutaml::Model::TransformationRegistry.instance.clear
+          end
+        end
+
+        it "round-trips xml" do
+          expect(generated_xml).to be_xml_equivalent_to(xml)
+        end
+      end
+    end
+
+    describe "validation errors" do
+      # rubocop:disable all
+      let(:mapping) { Lutaml::Xml::Mapping.new }
+      # rubocop:enable all
+
+      it "raises error when neither :to nor :with provided" do
+        expect do
+          mapping.map_element("test")
+        end.to raise_error(
+          Lutaml::Model::IncorrectMappingArgumentsError,
+          ":to or :with argument is required for mapping 'test'",
+        )
+      end
+
+      it "raises error when :with is missing :to or :from keys" do
+        expect do
+          mapping.map_element("test", with: { to: "value" })
+        end.to raise_error(
+          Lutaml::Model::IncorrectMappingArgumentsError,
+          ":with argument for mapping 'test' requires :to and :from keys",
+        )
+      end
+
+      it "does not raise error when :to is provided" do
+        expect do
+          mapping.map_element("test", to: :test, with: { from: "value" })
+        end.not_to raise_error
+      end
+
+      describe "map_attribute validations" do
+        it "raises error for invalid :with argument" do
+          expect do
+            mapping.map_attribute("test", with: { from: "value" })
+          end.to raise_error(
+            Lutaml::Model::IncorrectMappingArgumentsError,
+            ":with argument for mapping 'test' requires :to and :from keys",
+          )
+        end
+
+        it "does not raise error if to is provided" do
+          expect do
+            mapping.map_attribute("test", to: :test, with: { from: "value" })
+          end.not_to raise_error
+        end
+      end
+
+      describe "map_content validations" do
+        it "raises error when no :to provided" do
+          expect do
+            mapping.map_content
+          end.to raise_error(
+            Lutaml::Model::IncorrectMappingArgumentsError,
+            ":to or :with argument is required for mapping 'content'",
+          )
+        end
+      end
+
+      describe "map_attribute render_empty passthrough" do
+        # rubocop:disable all
+        let(:mapping) { Lutaml::Xml::Mapping.new }
+        # rubocop:enable all
+
+        it "passes render_empty: true through to MappingRule" do
+          mapping.map_attribute("tags", to: :tags, render_empty: true)
+          rule = mapping.find_by_to(:tags)
+          expect(rule.render_empty).to be(true)
+        end
+
+        it "passes render_empty: :omit through to MappingRule" do
+          mapping.map_attribute("tags", to: :tags, render_empty: :omit)
+          rule = mapping.find_by_to(:tags)
+          expect(rule.render_empty).to eq(:omit)
+        end
+
+        it "passes render_empty: :as_blank through to MappingRule" do
+          mapping.map_attribute("tags", to: :tags, render_empty: :as_blank)
+          rule = mapping.find_by_to(:tags)
+          expect(rule.render_empty).to eq(:as_blank)
+        end
+
+        it "renders empty collection as attribute when render_empty: true" do
+          model = XmlMappingSpec::RenderEmptyAttributeModel.new(tags: [])
+          result = model.to_xml
+          # render_empty: true renders the attribute even for empty collections
+          expect(result).to include('tags="[]"')
+        end
+      end
+    end
+  end
+
+  describe Lutaml::Xml::Adapter::NokogiriAdapter do
+    it_behaves_like "having XML Mappings", described_class
+  end
+
+  describe Lutaml::Xml::Adapter::OxAdapter do
+    if TestAdapterConfig.adapter_enabled?(:ox)
+      it_behaves_like "having XML Mappings",
+                      described_class
+    end
+  end
+
+  describe Lutaml::Xml::Adapter::OgaAdapter do
+    if TestAdapterConfig.adapter_enabled?(:oga)
+      it_behaves_like "having XML Mappings",
+                      described_class
+    end
+  end
+
+  describe Lutaml::Xml::Adapter::RexmlAdapter do
+    if TestAdapterConfig.adapter_enabled?(:rexml)
+      it_behaves_like "having XML Mappings", described_class
+    end
+  end
+end