lutaml-model 0.3.24 → 0.3.26

data/spec/lutaml/model/defaults_spec.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model"
+
+module DefaultsSpec
+  class GlazeTag < Lutaml::Model::Serializable
+    attribute :text, :string, default: -> { "" }
+
+    xml do
+      root "Tag"
+      map_content to: :text
+    end
+  end
+
+  class Glaze < Lutaml::Model::Serializable
+    attribute :name, :string, default: -> { "Standard Glaze" }
+    attribute :color, :string, default: -> { "Clear" }
+    attribute :opacity, :string, default: -> { "Opaque" }
+    attribute :temperature, :integer, default: -> { 1050 }
+    attribute :firing_time, :integer, default: -> { 60 }
+    attribute :balance, "Decimal", default: -> { BigDecimal("0.0") }
+    attribute :tags, GlazeTag, collection: true
+    attribute :properties, :hash, default: -> { { food_safe: true } }
+    attribute :status, :string, default: -> { "active" }
+    attribute :batch_number, :integer, default: -> { 0 }
+    attribute :manufacturer, :string, default: -> { "example@glazes.com" }
+    attribute :type, :string, values: %w[earthenware stoneware porcelain], default: -> {
+      "stoneware"
+    }
+
+    xml do
+      root "Glaze"
+      map_element "Name", to: :name
+      map_element "Color", to: :color
+      map_element "Opacity", to: :opacity, render_default: true
+      map_element "Temperature", to: :temperature
+      map_element "FiringTime", to: :firing_time, render_default: true
+      map_element "Balance", to: :balance
+      map_element "Tags", to: :tags
+      map_element "Properties", to: :properties
+      map_element "Status", to: :status
+      map_element "BatchNumber", to: :batch_number
+      map_element "Manufacturer", to: :manufacturer
+      map_element "Type", to: :type
+    end
+
+    json do
+      map "name", to: :name
+      map "color", to: :color
+      map "opacity", to: :opacity, render_default: true
+      map "temperature", to: :temperature
+      map "firingTime", to: :firing_time, render_default: true
+      map "balance", to: :balance
+      map "tags", to: :tags
+      map "properties", to: :properties
+      map "status", to: :status
+      map "batchNumber", to: :batch_number
+      map "manufacturer", to: :manufacturer
+      map "type", to: :type
+    end
+
+    yaml do
+      map "name", to: :name
+      map "color", to: :color
+    end
+  end
+
+  # Class for testing default values without render_default option
+  class BasicGlaze < Lutaml::Model::Serializable
+    attribute :name, :string, default: -> { "Basic Glaze" }
+    attribute :temperature, :integer, default: -> { 1050 }
+    attribute :opacity, :string, default: -> { "Opaque" }
+
+    xml do
+      root "BasicGlaze"
+      map_element "name", to: :name
+      map_element "temperature", to: :temperature
+      map_element "opacity", to: :opacity
+    end
+
+    json do
+      map "name", to: :name
+      map "temperature", to: :temperature
+      map "opacity", to: :opacity
+    end
+  end
+
+  # Class for testing explicit render_default: false
+  class NoDefaultGlaze < Lutaml::Model::Serializable
+    attribute :name, :string, default: -> { "No Default Glaze" }
+    attribute :temperature, :integer, default: -> { 1050 }
+    attribute :opacity, :string, default: -> { "Opaque" }
+
+    xml do
+      root "NoDefaultGlaze"
+      map_element "name", to: :name, render_default: false
+      map_element "temperature", to: :temperature, render_default: false
+      map_element "opacity", to: :opacity, render_default: false
+    end
+
+    json do
+      map "name", to: :name, render_default: false
+      map "temperature", to: :temperature, render_default: false
+      map "opacity", to: :opacity, render_default: false
+    end
+  end
+end
+
+RSpec.describe DefaultsSpec::Glaze do
+  describe "Default value initialization" do
+    subject(:default_model) { described_class.new }
+
+    it "initializes with correct default values" do
+      expect(default_model.name).to eq("Standard Glaze")
+      expect(default_model.color).to eq("Clear")
+      expect(default_model.opacity).to eq("Opaque")
+      expect(default_model.temperature).to eq(1050)
+      expect(default_model.firing_time).to eq(60)
+      expect(default_model.balance).to eq(BigDecimal("0.0"))
+      expect(default_model.tags).to eq([])
+      expect(default_model.properties).to eq({ food_safe: true })
+      expect(default_model.status).to eq("active")
+      expect(default_model.batch_number).to eq(0)
+      expect(default_model.manufacturer).to eq("example@glazes.com")
+      expect(default_model.type).to eq("stoneware")
+    end
+  end
+
+  describe "Default value rendering behavior" do
+    context "with XML serialization" do
+      context "when value is default" do
+        it "does not serialize when render_default is false" do
+          glaze = DefaultsSpec::NoDefaultGlaze.new
+          xml = glaze.to_xml
+
+          expect(xml).not_to include("<name>")
+          expect(xml).not_to include("<temperature>")
+          expect(xml).not_to include("<opacity>")
+        end
+
+        it "does not serialize when render_default is not set" do
+          glaze = DefaultsSpec::BasicGlaze.new
+          xml = glaze.to_xml
+
+          expect(xml).not_to include("<name>")
+          expect(xml).not_to include("<temperature>")
+          expect(xml).not_to include("<opacity>")
+        end
+
+        it "serializes when render_default is true" do
+          glaze = described_class.new
+          xml = glaze.to_xml
+
+          expect(xml).to include("<Opacity>Opaque</Opacity>")
+          expect(xml).to include("<FiringTime>60</FiringTime>")
+        end
+      end
+
+      context "when value is not default" do
+        it "serializes regardless of render_default setting" do
+          glaze = DefaultsSpec::NoDefaultGlaze.new(
+            name: "Custom Glaze",
+            temperature: 1200,
+            opacity: "Translucent",
+          )
+          xml = glaze.to_xml
+
+          expect(xml).to include("<name>Custom Glaze</name>")
+          expect(xml).to include("<temperature>1200</temperature>")
+          expect(xml).to include("<opacity>Translucent</opacity>")
+        end
+      end
+    end
+
+    context "with JSON serialization" do
+      context "when value is default" do
+        it "does not serialize when render_default is false" do
+          glaze = DefaultsSpec::NoDefaultGlaze.new
+          json = JSON.parse(glaze.to_json)
+
+          expect(json).not_to have_key("name")
+          expect(json).not_to have_key("temperature")
+          expect(json).not_to have_key("opacity")
+        end
+
+        it "does not serialize when render_default is not set" do
+          glaze = DefaultsSpec::BasicGlaze.new
+          json = JSON.parse(glaze.to_json)
+
+          expect(json).not_to have_key("name")
+          expect(json).not_to have_key("temperature")
+          expect(json).not_to have_key("opacity")
+        end
+
+        it "serializes when render_default is true" do
+          glaze = described_class.new
+          json = JSON.parse(glaze.to_json)
+
+          expect(json["opacity"]).to eq("Opaque")
+          expect(json["firingTime"]).to eq(60)
+        end
+      end
+
+      context "when value is not default" do
+        it "serializes regardless of render_default setting" do
+          glaze = DefaultsSpec::NoDefaultGlaze.new(
+            name: "Custom Glaze",
+            temperature: 1200,
+            opacity: "Translucent",
+          )
+          json = JSON.parse(glaze.to_json)
+
+          expect(json["name"]).to eq("Custom Glaze")
+          expect(json["temperature"]).to eq(1200)
+          expect(json["opacity"]).to eq("Translucent")
+        end
+      end
+    end
+  end
+end

data/spec/lutaml/model/delegation_spec.rb

@@ -0,0 +1,340 @@
+require "spec_helper"
+require "lutaml/model"
+
+module Delegation
+  class Glaze < Lutaml::Model::Serializable
+    attribute :color, Lutaml::Model::Type::String
+    attribute :finish, Lutaml::Model::Type::String
+  end
+
+  class Ceramic < Lutaml::Model::Serializable
+    attribute :type, Lutaml::Model::Type::String
+    attribute :glaze, Glaze
+
+    json do
+      map "type", to: :type
+      map "color", to: :color, delegate: :glaze
+      map "finish", to: :finish, delegate: :glaze
+    end
+
+    yaml do
+      map "type", to: :type
+      map "color", to: :color, delegate: :glaze
+      map "finish", to: :finish, delegate: :glaze
+    end
+
+    toml do
+      map "type", to: :type
+      map "color", to: :color, delegate: :glaze
+      map "finish", to: :finish, delegate: :glaze
+    end
+
+    xml do
+      root "delegation"
+      map_element "type", to: :type
+      map_element "color", to: :color, delegate: :glaze
+      map_element "finish", to: :finish, delegate: :glaze
+    end
+  end
+
+  class NamespacedTypeCeramic < Lutaml::Model::Serializable
+    attribute :type, Lutaml::Model::Type::String
+    attribute :glaze, Glaze
+
+    yaml do
+      map "type", to: :type
+      map "color", to: :color, delegate: :glaze
+      map "finish", to: :finish, delegate: :glaze
+    end
+
+    xml do
+      root "delegation"
+      map_element "type",
+                  to: :type,
+                  namespace: "https://example.com/type/1.2",
+                  prefix: "type"
+      map_element "color", to: :color, delegate: :glaze
+      map_element "finish", to: :finish, delegate: :glaze
+    end
+  end
+end
+
+RSpec.describe Delegation do
+  let(:yaml_data) do
+    <<~YAML
+      type: Vase
+      color: Blue
+      finish: Glossy
+    YAML
+  end
+
+  let(:delegation1) { Delegation::NamespacedTypeCeramic.from_yaml(yaml_data) }
+  let(:delegation) { Delegation::Ceramic.from_yaml(yaml_data) }
+
+  it "deserializes from YAML with delegation" do
+    expect(delegation.type).to eq("Vase")
+    expect(delegation.glaze.color).to eq("Blue")
+    expect(delegation.glaze.finish).to eq("Glossy")
+  end
+
+  it "serializes to YAML with delegation" do
+    expected_yaml = <<~YAML
+      ---
+      type: Vase
+      color: Blue
+      finish: Glossy
+    YAML
+    expect(delegation.to_yaml.strip).to eq(expected_yaml.strip)
+  end
+
+  it "serializes to JSON with delegation and filtering" do
+    expected_json = {
+      type: "Vase",
+      color: "Blue",
+    }.to_json
+
+    generated_json = delegation.to_json(only: %i[type color])
+
+    expect(JSON.parse(generated_json)).to eq(JSON.parse(expected_json))
+  end
+
+  it "serializes to JSON with pretty formatting" do
+    expected_pretty_json = {
+      type: "Vase",
+      color: "Blue",
+    }.to_json
+
+    generated_json = delegation.to_json(only: %i[type color], pretty: true)
+
+    expect(generated_json.strip).to eq(expected_pretty_json.strip)
+  end
+
+  it "serializes to XML with pretty formatting" do
+    expected_pretty_xml = <<~XML
+      <delegation>
+        <type>Vase</type>
+        <color>Blue</color>
+        <finish>Glossy</finish>
+      </delegation>
+    XML
+
+    generated_xml = delegation.to_xml(pretty: true).strip
+
+    expect(generated_xml).to be_equivalent_to(expected_pretty_xml.strip)
+  end
+
+  it "does not provide XML declaration if no declaration option provided" do
+    xml_data = delegation.to_xml(pretty: true)
+    expect(xml_data).not_to include("<?xml")
+  end
+
+  it "provides XML declaration with default version" \
+     "if declaration: true option provided" do
+    xml_data = delegation.to_xml(pretty: true, declaration: true)
+    expect(xml_data).to include('<?xml version="1.0"?>')
+  end
+
+  it "provides XML declaration with specified version" \
+     "if declaration: '1.1' option provided" do
+    xml_data = delegation.to_xml(pretty: true, declaration: "1.1")
+    expect(xml_data).to include('<?xml version="1.1"?>')
+  end
+
+  it "provides XML declaration without encoding" \
+     "if encoding option not provided" do
+    xml_data = delegation.to_xml(pretty: true, declaration: true)
+    expect(xml_data).to include('<?xml version="1.0"?>')
+    expect(xml_data).not_to include("encoding=")
+  end
+
+  it "provides XML declaration with UTF-8 encoding" \
+     "if encoding: true option provided" do
+    xml_data = delegation.to_xml(
+      pretty: true,
+      declaration: true,
+      encoding: true,
+    )
+    expect(xml_data).to include('<?xml version="1.0" encoding="UTF-8"?>')
+  end
+
+  it "provides XML declaration with specified encoding" \
+     "if encoding: 'ASCII' option provided" do
+    xml_data = delegation.to_xml(
+      pretty: true,
+      declaration: true,
+      encoding: "ASCII",
+    )
+    expect(xml_data).to include('<?xml version="1.0" encoding="ASCII"?>')
+  end
+
+  it "sets the namespace of a particular attribute inside <delegation>" do
+    Delegation::Ceramic.class_eval do
+      attribute :date, Lutaml::Model::Type::Date
+
+      xml do
+        root "delegation"
+        map_attribute "date",
+                      to: :date,
+                      namespace: "https://example.com/delegation/1.2",
+                      prefix: "del"
+        map_element "type", to: :type
+        map_element "color", to: :color, delegate: :glaze
+        map_element "finish", to: :finish, delegate: :glaze
+      end
+    end
+
+    delegation_class = Delegation::Ceramic
+    delegation = delegation_class.new(
+      type: "Vase",
+      glaze: Delegation::Glaze.new(
+        color: "Blue",
+        finish: "Glossy",
+      ),
+      date: "2024-06-08",
+    )
+
+    xml_data = delegation.to_xml(
+      pretty: true,
+      declaration: true,
+      encoding: "UTF-8",
+    )
+
+    delegation_attributes = [
+      'xmlns:del="https://example.com/delegation/1.2"',
+      'del:date="2024-06-08"',
+    ]
+
+    expect(xml_data).to include("<delegation #{delegation_attributes.join(' ')}>")
+  end
+
+  it "sets the default namespace of <delegation>" do
+    Delegation::Ceramic.class_eval do
+      xml do
+        root "delegation"
+        namespace "https://example.com/delegation/1.2"
+        map_element "type", to: :type
+        map_element "color", to: :color, delegate: :glaze
+        map_element "finish", to: :finish, delegate: :glaze
+      end
+    end
+
+    delegation_class = Delegation::Ceramic
+    delegation = delegation_class.from_yaml(yaml_data)
+    xml_data = delegation.to_xml(
+      pretty: true,
+      declaration: true,
+      encoding: "UTF-8",
+    )
+    expect(xml_data).to(
+      include('<delegation xmlns="https://example.com/delegation/1.2" xmlns:del="https://example.com/delegation/1.2">'),
+    )
+  end
+
+  it "sets the namespace of <delegation> with a prefix" do
+    Delegation::Ceramic.class_eval do
+      xml do
+        root "delegation"
+        namespace "https://example.com/delegation/1.2", "del"
+        map_element "type", to: :type
+        map_element "color", to: :color, delegate: :glaze
+        map_element "finish", to: :finish, delegate: :glaze
+      end
+    end
+
+    delegation_class = Delegation::Ceramic
+    delegation = delegation_class.from_yaml(yaml_data)
+    xml_data = delegation.to_xml(
+      pretty: true,
+      declaration: true,
+      encoding: "UTF-8",
+    )
+
+    expect(xml_data).to(
+      include(
+        '<del:delegation xmlns:del="https://example.com/delegation/1.2">',
+      ),
+    )
+  end
+
+  it "sets the namespace of <delegation> and also" \
+     "a particular element inside using :inherit" do
+    Delegation::Ceramic.class_eval do
+      xml do
+        root "delegation"
+        namespace "https://example.com/delegation/1.2", "del"
+        map_element "type", to: :type # , namespace: :inherit
+        map_element "color", to: :color, delegate: :glaze
+        map_element "finish", to: :finish, delegate: :glaze
+      end
+    end
+
+    delegation_class = Delegation::Ceramic
+    delegation = delegation_class.from_yaml(yaml_data)
+    xml_data = delegation.to_xml(
+      pretty: true,
+      declaration: true,
+      encoding: "UTF-8",
+    )
+
+    delegation_attribute = 'xmlns:del="https://example.com/delegation/1.2">'
+
+    expect(xml_data).to include("<del:delegation #{delegation_attribute}")
+    expect(xml_data).to include("<del:type>Vase</del:type>")
+  end
+
+  it "sets the namespace of <delegation> and also" \
+     "a particular attribute inside using :inherit" do
+    Delegation::Ceramic.class_eval do
+      attribute :date, Lutaml::Model::Type::Date
+
+      xml do
+        root "delegation"
+        namespace "https://example.com/delegation/1.1", "del1"
+        map_attribute "date",
+                      to: :date,
+                      namespace: "https://example.com/delegation/1.2",
+                      prefix: "del2"
+
+        map_element "type", to: :type, namespace: :inherit
+        map_element "color", to: :color, delegate: :glaze
+        map_element "finish", to: :finish, delegate: :glaze
+      end
+    end
+
+    delegation_class = Delegation::Ceramic
+    delegation = delegation_class.new(
+      type: "Vase",
+      glaze: Delegation::Glaze.new(
+        color: "Blue",
+        finish: "Glossy",
+      ),
+      date: "2024-06-08",
+    )
+
+    xml_data = delegation.to_xml(
+      pretty: true,
+      declaration: true,
+      encoding: "UTF-8",
+    )
+
+    delegation_attributes = [
+      'xmlns:del1="https://example.com/delegation/1.1"',
+      'xmlns:del2="https://example.com/delegation/1.2"',
+      'del2:date="2024-06-08"',
+    ]
+
+    expect(xml_data).to include("<del1:delegation #{delegation_attributes.join(' ')}>")
+    expect(xml_data).to include("<del1:type>Vase</del1:type>")
+  end
+
+  it "sets the namespace of a particular element inside Ceramic" do
+    delegation1 = Delegation::NamespacedTypeCeramic.from_yaml(yaml_data)
+    xml_data = delegation1.to_xml(
+      pretty: true,
+      declaration: true,
+      encoding: "UTF-8",
+    )
+    expect(xml_data).to include('<delegation xmlns:type="https://example.com/type/1.2">')
+    expect(xml_data).to include("<type:type>Vase</type:type>")
+  end
+end

data/spec/lutaml/model/inheritance_spec.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+require "lutaml/model"
+
+module InheritanceSpec
+  class Parent < Lutaml::Model::Serializable
+    attribute :text, Lutaml::Model::Type::String
+    attribute :id, Lutaml::Model::Type::String
+    attribute :name, Lutaml::Model::Type::String
+
+    xml do
+      map_content to: :text
+
+      map_attribute "id", to: :id
+      map_element "name", to: :name
+    end
+  end
+
+  class Child1 < Parent
+    attribute :age, Lutaml::Model::Type::Integer
+
+    xml do
+      root "child"
+
+      map_element "age", to: :age
+    end
+  end
+
+  class Child2 < Parent
+    attribute :age, Lutaml::Model::Type::Integer
+
+    xml do
+      root "child_two"
+
+      map_element "gender", to: :age
+    end
+  end
+end
+
+RSpec.describe "Inheritance" do
+  subject(:child_object) do
+    InheritanceSpec::Child1.new(
+      {
+        text: "Some text",
+        name: "John Doe",
+        id: "foobar",
+        age: 30,
+      },
+    )
+  end
+
+  let(:expected_xml) do
+    '<child id="foobar"><name>John Doe</name><age>30</age>Some text</child>'
+  end
+
+  it "uses parent attributes" do
+    expect(child_object.to_xml(pretty: true)).to eq(expected_xml)
+  end
+
+  context "with multiple child classes" do
+    describe "Child1" do
+      let(:child1) { InheritanceSpec::Child1 }
+
+      it "has correct mappings" do
+        expect(child1.mappings_for(:xml).mappings.count).to eq(4)
+      end
+
+      it "has correct attributes" do
+        expect(child1.attributes.count).to eq(4)
+      end
+
+      it "has correct model" do
+        expect(child1.model).to eq(child1)
+      end
+    end
+
+    describe "Child2" do
+      let(:child2) { InheritanceSpec::Child2 }
+
+      it "has correct mappings" do
+        expect(child2.mappings_for(:xml).mappings.count).to eq(4)
+      end
+
+      it "has correct attributes" do
+        expect(child2.attributes.count).to eq(4)
+      end
+
+      it "has correct model" do
+        expect(child2.model).to eq(child2)
+      end
+    end
+  end
+end

data/spec/lutaml/model/json_adapter_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+require "lutaml/model/json_adapter/standard_json_adapter"
+require "lutaml/model/json_adapter/multi_json_adapter"
+require_relative "../../fixtures/sample_model"
+
+RSpec.shared_examples "a JSON adapter" do |adapter_class|
+  let(:attributes) { { name: "John Doe", age: 30 } }
+  let(:model) { SampleModel.new(attributes) }
+
+  let(:expected_json) do
+    if adapter_class == Lutaml::Model::JsonAdapter::StandardJsonAdapter
+      JSON.generate(attributes)
+    elsif adapter_class == Lutaml::Model::JsonAdapter::MultiJsonAdapter
+      MultiJson.dump(attributes)
+    end
+  end
+
+  it "serializes to JSON" do
+    json = adapter_class.new(attributes).to_json
+    expect(json).to eq(expected_json)
+  end
+
+  it "deserializes from JSON" do
+    doc = adapter_class.parse(expected_json)
+    new_model = SampleModel.new(doc.to_h)
+    expect(new_model.name).to eq("John Doe")
+    expect(new_model.age).to eq(30)
+  end
+end
+
+RSpec.describe Lutaml::Model::JsonAdapter::StandardJsonAdapter do
+  it_behaves_like "a JSON adapter", described_class
+end
+
+RSpec.describe Lutaml::Model::JsonAdapter::MultiJsonAdapter do
+  it_behaves_like "a JSON adapter", described_class
+end