lutaml-model 0.5.3 → 0.6.0

data/spec/lutaml/model/with_child_mapping_spec.rb

@@ -341,7 +341,7 @@ RSpec.describe ChildMapping do
         actual = Lutaml::Model::Config.toml_adapter.parse(instance.to_toml)
         expected = Lutaml::Model::Config.toml_adapter.parse(toml)
 
-        expect(actual.attributes).to eq(expected.attributes)
+        expect(actual).to eq(expected)
       end
 
       it "converts object to toml with nesting values" do
@@ -349,7 +349,7 @@ RSpec.describe ChildMapping do
         actual = Lutaml::Model::Config.toml_adapter.parse(instance.to_toml)
         expected = Lutaml::Model::Config.toml_adapter.parse(prefixes_toml)
 
-        expect(actual.attributes).to eq(expected.attributes)
+        expect(actual).to eq(expected)
       end
     end
   end

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

@@ -14,7 +14,7 @@ RSpec.describe Lutaml::Model::XmlAdapter::OgaAdapter do
   let(:document) { described_class.parse(xml_string) }
 
   context "parsing XML with namespaces" do
-    let(:child) { document.root.children[1] }
+    let(:child) { document.root.children.first }
 
     it "parses the root element with default namespace" do
       expect(document.root.name).to eq("root")
@@ -39,18 +39,22 @@ RSpec.describe Lutaml::Model::XmlAdapter::OgaAdapter do
 
   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)
+      xml_output = document.root.to_xml
+      parsed_output = Moxml::Adapter::Oga.parse(xml_output)
 
       root = parsed_output.children.first
       expect(root.name).to eq("root")
       expect(root.namespace.uri).to eq("http://example.com/default")
 
-      child = root.children[1]
-      expect(child.expanded_name).to eq("prefix:child")
+      child = root.children.first
+      expect(described_class.prefixed_name_of(child)).to eq("prefix: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")
+      unprefixed_attr = child.attributes.find { |attr| attr.name == "attr" }
+      expect(unprefixed_attr.value).to eq("value")
+      prefixed_attr = child.attributes.find do |attr|
+        described_class.prefixed_name_of(attr) == "prefix:attr"
+      end
+      expect(prefixed_attr.value).to eq("prefixed_value")
     end
   end
 end

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

@@ -123,6 +123,20 @@ RSpec.shared_context "XML namespace models" do
       map_element "body", to: :body
     end
   end
+
+  class OwnedEnd < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :type, :string
+    attribute :uml_type, :string
+
+    xml do
+      root "ownedEnd"
+
+      map_attribute "id", to: :id, namespace: "http://www.omg.org/spec/XMI/20131001", prefix: "xmi"
+      map_attribute "type", to: :type, namespace: "http://www.omg.org/spec/XMI/20131001", prefix: "xmi"
+      map_attribute "type", to: :uml_type
+    end
+  end
 end
 
 RSpec.shared_examples "XML serialization with namespace" do |model_class, xml_string|
@@ -302,6 +316,44 @@ RSpec.shared_examples "an XML namespace parser" do |adapter_class|
       end
     end
   end
+
+  context "when two attributes have same name but different prefix" do
+    let(:xml_input) do
+      <<~XML
+        <ownedEnd xmlns:xmi="http://www.omg.org/spec/XMI/20131001"
+                  xmi:type="xmi_type"
+                  xmi:id="my_id"
+                  type="test" />
+      XML
+    end
+
+    describe "XML serialization" do
+      it "correctly deserializes from XML" do
+        owned_end = OwnedEnd.from_xml(xml_input)
+
+        expect(owned_end.id).to eq("my_id")
+        expect(owned_end.type).to eq("xmi_type")
+        expect(owned_end.uml_type).to eq("test")
+      end
+
+      it "correctly serializes to XML" do
+        owned_end = OwnedEnd.new(
+          id: "my_id",
+          type: "xmi_type",
+          uml_type: "test",
+        )
+
+        expect(owned_end.to_xml).to be_equivalent_to(xml_input)
+      end
+
+      it "round-trips XML" do
+        owned_end = OwnedEnd.from_xml(xml_input)
+        output_xml = owned_end.to_xml
+
+        expect(output_xml).to be_equivalent_to(xml_input)
+      end
+    end
+  end
 end
 
 RSpec.describe Lutaml::Model::XmlAdapter::NokogiriAdapter do

data/spec/lutaml/model/xml_mapping_rule_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+require "lutaml/model/xml_adapter/ox_adapter"
+require "lutaml/model/xml_adapter/oga_adapter"
+
+require_relative "../../../lib/lutaml/model/xml_mapping_rule"
+
+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
+
+RSpec.describe Lutaml::Model::XmlMappingRule do
+  context "with Xml Mapping Rule" do
+    let(:orig_mapping_rule) do
+      described_class.new(
+        "name",
+        to: :name,
+        render_nil: true,
+        render_default: true,
+        with: { to: :content_to_xml, from: :content_from_xml },
+        delegate: true,
+        namespace: "http://child-namespace",
+        prefix: "cn",
+        mixed_content: true,
+        cdata: true,
+        namespace_set: true,
+        prefix_set: true,
+        attribute: true,
+        default_namespace: "http://parent-namespace",
+      )
+    end
+
+    let(:dup_mapping_rule) do
+      orig_mapping_rule.deep_dup
+    end
+
+    it "duplicates all instance variables" do
+      orig_mapping_rule.instance_variables.each do |variable|
+        orig_var = orig_mapping_rule.instance_variable_get(variable)
+        dup_var = dup_mapping_rule.instance_variable_get(variable)
+
+        expect(orig_var).to eq(dup_var)
+      end
+    end
+  end
+end