lutaml-model 0.3.23 → 0.3.25

data/spec/lutaml/model/xml_adapter/oga_adapter_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+require "oga"
+require_relative "../../../../lib/lutaml/model/xml_adapter/oga_adapter"
+
+RSpec.xdescribe Lutaml::Model::XmlAdapter::OgaAdapter do
+  let(:xml_string) do
+    <<~XML
+      <root xmlns="http://example.com/default" xmlns:prefix="http://example.com/prefixed">
+        <prefix:child attr="value" prefix:attr="prefixed_value">Text</prefix:child>
+      </root>
+    XML
+  end
+
+  let(:document) { described_class.parse(xml_string) }
+
+  context "parsing XML with namespaces" do
+    it "parses the root element with default namespace" do
+      expect(document.root.name).to eq("root")
+      expect(document.root.namespace).to eq("http://example.com/default")
+      expect(document.root.namespace_prefix).to be_nil
+    end
+
+    it "parses child element with prefixed namespace" do
+      child = document.root.children.first
+      expect(child.name).to eq("child")
+      expect(child.namespace).to eq("http://example.com/prefixed")
+      expect(child.namespace_prefix).to eq("prefix")
+    end
+
+    it "parses attributes with and without namespaces" do
+      child = document.root.children.first
+      expect(child.attributes["attr"].value).to eq("value")
+      expect(child.attributes["attr"].namespace).to be_nil
+      expect(child.attributes["prefix:attr"].value).to eq("prefixed_value")
+      expect(child.attributes["prefix:attr"].namespace).to eq("http://example.com/prefixed")
+      expect(child.attributes["prefix:attr"].namespace_prefix).to eq("prefix")
+    end
+  end
+
+  context "generating XML with namespaces" do
+    it "generates XML with namespaces correctly" do
+      xml_output = document.to_xml
+      parsed_output = Oga.parse_xml(xml_output)
+
+      root = parsed_output.root
+      expect(root.name).to eq("root")
+      expect(root.namespace.uri).to eq("http://example.com/default")
+
+      child = root.children.first
+      expect(child.name).to eq("child")
+      expect(child.namespace.uri).to eq("http://example.com/prefixed")
+      expect(child.get("attr")).to eq("value")
+      expect(child.get("prefix:attr")).to eq("prefixed_value")
+    end
+  end
+end

data/spec/lutaml/model/xml_adapter/ox_adapter_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+require "ox"
+require_relative "../../../../lib/lutaml/model/xml_adapter/ox_adapter"
+
+RSpec.describe Lutaml::Model::XmlAdapter::OxAdapter do
+  let(:xml_string) do
+    <<-XML
+      <root xmlns="http://example.com/default" xmlns:prefix="http://example.com/prefixed">
+        <prefix:child attr="value" prefix:attr="prefixed_value">Text</prefix:child>
+        <!-- just-a-comment -->
+      </root>
+    XML
+  end
+
+  let(:document) { described_class.parse(xml_string) }
+
+  context "parsing XML with namespaces" do
+    it "parses the root element with default namespace" do
+      expect(document.root.name).to eq("root")
+      expect(document.root.namespace.uri).to eq("http://example.com/default")
+      expect(document.root.namespace.prefix).to be_nil
+    end
+
+    it "parses child element with prefixed namespace" do
+      child = document.root.children.first
+      expect(child.name).to eq("prefix:child")
+      expect(child.namespace.uri).to eq("http://example.com/prefixed")
+      expect(child.namespace.prefix).to eq("prefix")
+    end
+
+    it "parses comment" do
+      expect(document.root.nodes.last.text).to eq("just-a-comment")
+    end
+
+    it "parses attributes with and without namespaces" do
+      child = document.root.children.first
+      expect(child.attributes["attr"].value).to eq("value")
+      expect(child.attributes["attr"].namespace).to be_nil
+      expect(child.attributes["prefix:attr"].value).to eq("prefixed_value")
+      expect(child.attributes["prefix:attr"].namespace).to eq("http://example.com/prefixed")
+      expect(child.attributes["prefix:attr"].namespace_prefix).to eq("prefix")
+    end
+  end
+
+  context "generating XML with namespaces" do
+    it "generates XML with namespaces correctly" do
+      xml_output = document.to_xml
+      parsed_output = Ox.parse(xml_output)
+
+      root = parsed_output
+      expect(root.name).to eq("root")
+      expect(root.attributes[:xmlns]).to eq("http://example.com/default")
+      expect(root.attributes[:"xmlns:prefix"]).to eq("http://example.com/prefixed")
+
+      child = root.nodes.first
+      expect(child.name).to eq("prefix:child")
+      expect(child.attributes[:attr]).to eq("value")
+      expect(child.attributes[:"prefix:attr"]).to eq("prefixed_value")
+    end
+  end
+end

data/spec/lutaml/model/xml_adapter/xml_namespace_spec.rb

@@ -0,0 +1,251 @@
+require "spec_helper"
+require "lutaml/model/xml_adapter/nokogiri_adapter"
+require "lutaml/model/xml_adapter/ox_adapter"
+require "lutaml/model/xml_adapter/oga_adapter"
+require "lutaml/model"
+
+RSpec.shared_context "XML namespace models" do
+  class TestModelNoPrefix < Lutaml::Model::Serializable
+    attribute :name, :string
+
+    xml do
+      root "test"
+      namespace "http://example.com/test", "test"
+      map_element "name", to: :name
+    end
+  end
+
+  class TestModelWithPrefix < Lutaml::Model::Serializable
+    attribute :name, :string
+
+    xml do
+      root "test"
+      namespace "http://example.com/test", "test"
+      map_element "name", to: :name
+    end
+  end
+
+  class SamplePrefixedNamespacedModel < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :lang, :string
+    attribute :name, :string, default: -> { "Anonymous" }
+    attribute :age, :integer, default: -> { 18 }
+
+    xml do
+      root "SamplePrefixedNamespacedModel"
+      namespace "http://example.com/foo", "foo"
+
+      map_attribute "id", to: :id
+      map_attribute "lang", to: :lang,
+                            prefix: "xml",
+                            namespace: "http://example.com/xml"
+
+      map_element "Name", to: :name, prefix: "bar", namespace: "http://example.com/bar"
+      map_element "Age", to: :age, prefix: "baz", namespace: "http://example.com/baz"
+    end
+  end
+
+  class NamespaceNilPrefixedNamespaced < Lutaml::Model::Serializable
+    attribute :namespace_model, SamplePrefixedNamespacedModel
+
+    xml do
+      root "NamespaceNil"
+      map_element "SamplePrefixedNamespacedModel", to: :namespace_model,
+                                                   namespace: nil,
+                                                   prefix: nil
+    end
+  end
+
+  class SampleDefaultNamespacedModel < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :lang, :string
+    attribute :name, :string, default: -> { "Anonymous" }
+    attribute :age, :integer, default: -> { 18 }
+
+    xml do
+      root "SampleDefaultNamespacedModel"
+      namespace "http://example.com/foo"
+
+      map_attribute "id", to: :id
+      map_attribute "lang", to: :lang,
+                            prefix: "xml",
+                            namespace: "http://example.com/xml"
+
+      map_element "Name", to: :name, prefix: "bar", namespace: "http://example.com/bar"
+      map_element "Age", to: :age, prefix: "baz", namespace: "http://example.com/baz"
+    end
+  end
+
+  class NamespaceNilDefaultNamespaced < Lutaml::Model::Serializable
+    attribute :namespace_model, SampleDefaultNamespacedModel
+
+    xml do
+      root "NamespaceNil"
+      map_element "SampleDefaultNamespacedModel", to: :namespace_model,
+                                                  namespace: nil,
+                                                  prefix: nil
+    end
+  end
+end
+
+RSpec.shared_examples "XML serialization with namespace" do |model_class, xml_string|
+  it "serializes to XML" do
+    model = model_class.new(name: "Test Name")
+    expect(model.to_xml).to be_equivalent_to(xml_string)
+  end
+
+  it "deserializes from XML" do
+    model = model_class.from_xml(xml_string)
+    expect(model.name).to eq("Test Name")
+  end
+end
+
+RSpec.shared_examples "an XML namespace parser" do |adapter_class|
+  include_context "XML namespace models"
+
+  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
+
+  context "with no prefix" do
+    include_examples "XML serialization with namespace",
+                     TestModelNoPrefix,
+                     '<test xmlns="http://example.com/test"><name>Test Name</name></test>'
+  end
+
+  context "with prefix" do
+    include_examples "XML serialization with namespace",
+                     TestModelWithPrefix,
+                     '<test:test xmlns:test="http://example.com/test"><test:name>Test Name</test:name></test:test>'
+  end
+
+  context "with prefixed namespace" do
+    let(:attributes) { { name: "John Doe", age: 30 } }
+    let(:model) { SamplePrefixedNamespacedModel.new(attributes) }
+
+    it "serializes to XML" do
+      expected_xml = <<~XML
+        <foo:SamplePrefixedNamespacedModel xmlns:foo="http://example.com/foo" xmlns:bar="http://example.com/bar" xmlns:baz="http://example.com/baz">
+          <bar:Name>John Doe</bar:Name>
+          <baz:Age>30</baz:Age>
+        </foo:SamplePrefixedNamespacedModel>
+      XML
+
+      expect(model.to_xml).to be_equivalent_to(expected_xml)
+    end
+
+    it "deserializes from XML" do
+      xml = <<~XML
+        <foo:SamplePrefixedNamespacedModel xmlns:foo="http://example.com/foo" xmlns:bar="http://example.com/bar" xmlns:baz="http://example.com/baz">
+          <bar:Name>John Doe</bar:Name>
+          <baz:Age>30</baz:Age>
+        </foo:SamplePrefixedNamespacedModel>
+      XML
+
+      new_model = SamplePrefixedNamespacedModel.from_xml(xml)
+      expect(new_model.name).to eq("John Doe")
+      expect(new_model.age).to eq(30)
+    end
+
+    it "round-trips if namespace is set" do
+      xml = <<~XML
+        <foo:SamplePrefixedNamespacedModel xml:lang="en" xmlns:foo="http://example.com/foo" xmlns:bar="http://example.com/bar" xmlns:baz="http://example.com/baz">
+          <bar:Name>John Doe</bar:Name>
+          <baz:Age>30</baz:Age>
+        </foo:SamplePrefixedNamespacedModel>
+      XML
+
+      doc = SamplePrefixedNamespacedModel.from_xml(xml)
+      generated_xml = doc.to_xml
+      expect(generated_xml).to be_equivalent_to(xml)
+    end
+
+    it "round-trips if namespace is set to nil in parent" do
+      xml = <<~XML
+        <NamespaceNil xmlns:foo="http://example.com/foo" xmlns:bar="http://example.com/bar" xmlns:baz="http://example.com/baz">
+          <SamplePrefixedNamespacedModel xml:lang="en">
+            <bar:Name>John Doe</bar:Name>
+            <baz:Age>30</baz:Age>
+          </SamplePrefixedNamespacedModel>
+        </NamespaceNil>
+      XML
+
+      doc = NamespaceNilPrefixedNamespaced.from_xml(xml)
+      generated_xml = doc.to_xml
+      expect(generated_xml).to be_equivalent_to(xml)
+    end
+  end
+
+  context "with default namespace" do
+    let(:attributes) { { name: "Jane Smith", age: 25 } }
+    let(:model) { SampleDefaultNamespacedModel.new(attributes) }
+
+    it "serializes to XML" do
+      expected_xml = <<~XML
+        <SampleDefaultNamespacedModel xmlns="http://example.com/foo" xmlns:bar="http://example.com/bar" xmlns:baz="http://example.com/baz">
+          <bar:Name>Jane Smith</bar:Name>
+          <baz:Age>25</baz:Age>
+        </SampleDefaultNamespacedModel>
+      XML
+
+      expect(model.to_xml).to be_equivalent_to(expected_xml)
+    end
+
+    it "deserializes from XML" do
+      xml = <<~XML
+        <SampleDefaultNamespacedModel xmlns="http://example.com/foo" xmlns:bar="http://example.com/bar" xmlns:baz="http://example.com/baz">
+          <bar:Name>Jane Smith</bar:Name>
+          <baz:Age>25</baz:Age>
+        </SampleDefaultNamespacedModel>
+      XML
+
+      new_model = SampleDefaultNamespacedModel.from_xml(xml)
+      expect(new_model.name).to eq("Jane Smith")
+      expect(new_model.age).to eq(25)
+    end
+
+    it "round-trips if namespace is set" do
+      xml = <<~XML
+        <SampleDefaultNamespacedModel xml:lang="en" xmlns="http://example.com/foo" xmlns:bar="http://example.com/bar" xmlns:baz="http://example.com/baz">
+          <bar:Name>Jane Smith</bar:Name>
+          <baz:Age>25</baz:Age>
+        </SampleDefaultNamespacedModel>
+      XML
+
+      doc = SampleDefaultNamespacedModel.from_xml(xml)
+      generated_xml = doc.to_xml
+      expect(generated_xml).to be_equivalent_to(xml)
+    end
+
+    it "round-trips if namespace is set to nil in parent" do
+      xml = <<~XML
+        <NamespaceNil xmlns:bar="http://example.com/bar" xmlns:baz="http://example.com/baz">
+          <SampleDefaultNamespacedModel xml:lang="en">
+            <bar:Name>Jane Smith</bar:Name>
+            <baz:Age>25</baz:Age>
+          </SampleDefaultNamespacedModel>
+        </NamespaceNil>
+      XML
+
+      doc = NamespaceNilDefaultNamespaced.from_xml(xml)
+      generated_xml = doc.to_xml
+      expect(generated_xml).to be_equivalent_to(xml)
+    end
+  end
+end
+
+RSpec.describe Lutaml::Model::XmlAdapter::NokogiriAdapter do
+  it_behaves_like "an XML namespace parser", described_class
+end
+
+RSpec.describe Lutaml::Model::XmlAdapter::OxAdapter do
+  it_behaves_like "an XML namespace parser", described_class
+end
+
+RSpec.xdescribe Lutaml::Model::XmlAdapter::OgaAdapter do
+  it_behaves_like "an XML namespace parser", described_class
+end

data/spec/lutaml/model/xml_adapter_spec.rb

@@ -0,0 +1,178 @@
+require "spec_helper"
+require "lutaml/model/xml_adapter/nokogiri_adapter"
+require "lutaml/model/xml_adapter/ox_adapter"
+require "lutaml/model/xml_adapter/oga_adapter"
+require_relative "../../fixtures/sample_model"
+
+module XmlAdapterSpec
+  class Mstyle < Lutaml::Model::Serializable
+    attribute :displaystyle, :string, default: -> { "true" }
+    attribute :color, :string
+    attribute :finish, :string, default: -> { "yes" }
+
+    xml do
+      root "mstyle"
+
+      map_attribute :displaystyle, to: :displaystyle, render_default: true
+    end
+  end
+
+  class Maths < Lutaml::Model::Serializable
+    attribute :display, :string, default: -> { "block" }
+    attribute :style, Mstyle, default: -> { Mstyle.new }
+
+    xml do
+      root "math"
+
+      map_attribute :display, to: :display
+      map_attribute "color", to: :color, delegate: :style
+      map_attribute "finish", to: :finish, delegate: :style,
+                              render_default: true
+      map_element :mstyle, to: :style, render_default: true
+    end
+  end
+end
+
+RSpec.shared_examples "an XML adapter" 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
+
+  before do
+    # Ensure BigDecimal is loaded because it is being used in sample model
+    require "bigdecimal"
+  end
+
+  let(:attributes) { { name: "John Doe", age: 30 } }
+  let(:model) { SampleModel.new(attributes) }
+
+  context "with default value" do
+    it "set display attribute correctly, other attributes default" do
+      xml = "<math display='true'></math>"
+
+      parsed = XmlAdapterSpec::Maths.from_xml(xml)
+      expect(parsed.display).to eq("true")
+      expect(parsed.style.class).to eq(XmlAdapterSpec::Mstyle)
+      expect(parsed.style.displaystyle).to eq("true")
+    end
+
+    it "set style attribute correctly, other attributes default" do
+      xml = "<math> <mstyle displaystyle='false'>  </mstyle> </math>"
+
+      parsed = XmlAdapterSpec::Maths.from_xml(xml)
+      expect(parsed.display).to eq("block")
+      expect(parsed.style.class).to eq(XmlAdapterSpec::Mstyle)
+      expect(parsed.style.displaystyle).to eq("false")
+    end
+
+    it "sets attributes default values" do
+      xml = "<math> </math>"
+
+      parsed = XmlAdapterSpec::Maths.from_xml(xml)
+      expect(parsed.display).to eq("block")
+      expect(parsed.style.class).to eq(XmlAdapterSpec::Mstyle)
+      expect(parsed.style.displaystyle).to eq("true")
+    end
+
+    it "delegate attributes with value" do
+      xml = "<math color='blue' finish='no'></math>"
+
+      parsed = XmlAdapterSpec::Maths.from_xml(xml)
+      expect(parsed.style.color).to eq("blue")
+      expect(parsed.style.finish).to eq("no")
+      expect(parsed.style.displaystyle).to eq("true")
+    end
+
+    it "delegate attributes with one value" do
+      xml = "<math color='blue'></math>"
+
+      parsed = XmlAdapterSpec::Maths.from_xml(xml)
+      expect(parsed.style.color).to eq("blue")
+      expect(parsed.style.finish).to eq("yes")
+      expect(parsed.style.displaystyle).to eq("true")
+    end
+
+    it "delegate attributes with no value" do
+      xml = "<math></math>"
+
+      parsed = XmlAdapterSpec::Maths.from_xml(xml)
+      expect(parsed.style.color).to be_nil
+      expect(parsed.style.finish).to eq("yes")
+      expect(parsed.style.displaystyle).to eq("true")
+    end
+
+    it "round-trips XML and add default values" do
+      input_xml = <<~XML
+        <math display='true'></math>
+      XML
+
+      output_xml = <<~XML
+        <math display="true" finish="yes">
+          <mstyle displaystyle="true"/>
+        </math>
+      XML
+
+      parsed = XmlAdapterSpec::Maths.from_xml(input_xml)
+
+      expect(parsed.to_xml.strip).to eq(output_xml.strip)
+    end
+  end
+
+  it "serializes to XML" do
+    expected_xml = <<~XML
+      <SampleModel>
+        <Name>John Doe</Name>
+        <Age>30</Age>
+      </SampleModel>
+    XML
+
+    doc = adapter_class.parse(expected_xml)
+    xml = doc.to_xml
+    expect(xml).to be_equivalent_to(expected_xml)
+  end
+
+  it "serializes to XML with only content" do
+    expected_xml = <<~XML
+      <Tag>
+        Bug
+      </Tag>
+    XML
+
+    doc = SampleModelTag.from_xml(expected_xml)
+    xml = doc.to_xml
+    expect(xml).to be_equivalent_to(expected_xml)
+  end
+
+  it "deserializes from XML" do
+    xml = <<~XML
+      <SampleModel>
+        <Name>John Doe</Name>
+        <Age>30</Age>
+      </SampleModel>
+    XML
+
+    doc = adapter_class.parse(xml)
+    new_model = SampleModel.new(doc.root.children.to_h do |child|
+      [child.name.downcase.to_sym, child.text]
+    end)
+    expect(new_model.name).to eq("John Doe")
+    expect(new_model.age).to eq(30)
+  end
+end
+
+RSpec.describe Lutaml::Model::XmlAdapter::NokogiriAdapter do
+  it_behaves_like "an XML adapter", described_class
+end
+
+RSpec.describe Lutaml::Model::XmlAdapter::OxAdapter do
+  it_behaves_like "an XML adapter", described_class
+end
+
+RSpec.xdescribe Lutaml::Model::XmlAdapter::OgaAdapter do
+  it_behaves_like "an XML adapter", described_class
+end