lutaml-model 0.3.23 → 0.3.25

data/spec/lutaml/model/ordered_content_spec.rb

@@ -0,0 +1,83 @@
+# spec/lutaml/model/ordered_content_spec.rb
+
+require "spec_helper"
+require "lutaml/model"
+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 OrderedContentSpec
+  class RootOrderedContent < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :bold, :string, collection: true
+    attribute :italic, :string, collection: true
+    attribute :underline, :string
+    attribute :content, :string
+
+    xml do
+      root "RootOrderedContent", ordered: true
+      map_attribute :id, to: :id
+      map_element :bold, to: :bold
+      map_element :italic, to: :italic
+      map_element :underline, to: :underline
+      map_content to: :content
+    end
+  end
+end
+
+RSpec.describe "OrderedContent" do
+  shared_examples "ordered content behavior" 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
+
+    context "when ordered: true is set at root" do
+      let(:xml) do
+        <<~XML
+          <RootOrderedContent id="123">
+            The Earth's Moon rings like a <bold>bell</bold> when struck by
+            meteroids. Distanced from the Earth by <italic>384,400 km</italic>,
+            its surface is covered in <underline>craters</underline>.
+            Ain't that <bold>cool</bold>?
+          </RootOrderedContent>
+        XML
+      end
+
+      let(:expected_xml) do
+        <<~XML
+          <RootOrderedContent id="123">
+            <bold>bell</bold>
+            <italic>384,400 km</italic>
+            <underline>craters</underline>
+            <bold>cool</bold>
+            The Earth's Moon rings like a  when struck by
+            meteroids. Distanced from the Earth by ,
+            its surface is covered in . Ain't that ?
+          </RootOrderedContent>
+        XML
+      end
+
+      it "deserializes and serializes ordered content correctly" do
+        serialized = OrderedContentSpec::RootOrderedContent.from_xml(xml).to_xml
+        expect(serialized).to be_equivalent_to(expected_xml)
+      end
+    end
+  end
+
+  describe Lutaml::Model::XmlAdapter::NokogiriAdapter do
+    it_behaves_like "ordered content behavior", described_class
+  end
+
+  describe Lutaml::Model::XmlAdapter::OxAdapter do
+    it_behaves_like "ordered content behavior", described_class
+  end
+
+  describe Lutaml::Model::XmlAdapter::OgaAdapter, skip: "Not implemented yet" do
+    it_behaves_like "ordered content behavior", described_class
+  end
+end

data/spec/lutaml/model/render_nil_spec.rb

@@ -0,0 +1,138 @@
+require "spec_helper"
+require "lutaml/model"
+
+class RenderNilNested < Lutaml::Model::Serializable
+  attribute :name, Lutaml::Model::Type::String
+
+  xml do
+    root "render_nil_nested"
+
+    map_element "name", to: :name
+  end
+end
+
+class RenderNil < Lutaml::Model::Serializable
+  attribute :name, Lutaml::Model::Type::String, default: -> {
+                                                           "Unnamed Pottery"
+                                                         }
+  attribute :clay_type, Lutaml::Model::Type::String
+  attribute :glaze, Lutaml::Model::Type::String
+  attribute :dimensions, Lutaml::Model::Type::String, collection: true
+  attribute :render_nil_nested, RenderNilNested
+
+  json do
+    map "name", to: :name, render_nil: true
+    map "clay_type", to: :clay_type, render_nil: true
+    map "glaze", to: :glaze, render_nil: true
+    map "dimensions", to: :dimensions, render_nil: false
+  end
+
+  xml do
+    root "render_nil"
+    map_element "name", to: :name, render_nil: true
+    map_element "clay_type", to: :clay_type, render_nil: false
+    map_element "glaze", to: :glaze, render_nil: true
+    map_element "render_nil_nested", to: :render_nil_nested, render_nil: true,
+                                     render_default: true
+    map_element "dimensions", to: :dimensions, render_nil: false
+  end
+
+  yaml do
+    map "name", to: :name, render_nil: true
+    map "clay_type", to: :clay_type, render_nil: false
+    map "glaze", to: :glaze, render_nil: true
+    map "dimensions", to: :dimensions, render_nil: false
+  end
+
+  toml do
+    map "name", to: :name, render_nil: true
+    map "clay_type", to: :clay_type, render_nil: false
+    map "glaze", to: :glaze, render_nil: true
+    map "dimensions", to: :dimensions, render_nil: false
+  end
+end
+
+RSpec.describe RenderNil do
+  let(:attributes) do
+    {
+      name: nil,
+      clay_type: nil,
+      glaze: nil,
+      dimensions: nil,
+    }
+  end
+  let(:model) { described_class.new(attributes) }
+
+  it "serializes to JSON with render_nil option" do
+    expected_json = {
+      name: nil,
+      clay_type: nil,
+      glaze: nil,
+      dimensions: [],
+    }.to_json
+
+    expect(model.to_json).to eq(expected_json)
+  end
+
+  it "deserializes from JSON with render_nil option" do
+    json = attributes.to_json
+    pottery = described_class.from_json(json)
+    expect(pottery.name).to be_nil
+    expect(pottery.clay_type).to be_nil
+    expect(pottery.glaze).to be_nil
+    expect(pottery.dimensions).to eq([])
+  end
+
+  it "serializes to XML with render_nil option" do
+    expected_xml = <<~XML
+      <render_nil>
+        <name/>
+        <glaze/>
+        <render_nil_nested/>
+      </render_nil>
+    XML
+
+    expect(model.to_xml).to be_equivalent_to(expected_xml)
+  end
+
+  it "deserializes from XML with render_nil option" do
+    xml = <<~XML
+      <render_nil>
+        <name/>
+        <glaze/>
+      </render_nil>
+    XML
+
+    pottery = described_class.from_xml(xml)
+    expect(pottery.name).to be_nil
+    expect(pottery.glaze).to be_nil
+  end
+
+  it "serializes to YAML with render_nil option" do
+    expected_yaml = <<~YAML
+      ---
+      name:
+      glaze:
+      dimensions: []
+    YAML
+
+    generated_yaml = model.to_yaml.strip
+
+    # Removing empty spaces from the end of the line because of and issue in
+    # libyaml -> https://github.com/yaml/libyaml/issues/46
+    generated_yaml = generated_yaml.gsub(": \n", ":\n")
+
+    expect(generated_yaml).to eq(expected_yaml.strip)
+  end
+
+  it "deserializes from YAML with render_nil option" do
+    yaml = <<~YAML
+      ---
+      glaze:
+    YAML
+
+    pottery = described_class.from_yaml(yaml)
+    expect(pottery.name).to eq("Unnamed Pottery")
+    expect(pottery.glaze).to be_nil
+  end
+end

data/spec/lutaml/model/schema/json_schema_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper"
+require "lutaml/model/schema"
+
+RSpec.describe Lutaml::Model::Schema::JsonSchema do
+  module SchemaGeneration
+    class Glaze < Lutaml::Model::Serializable
+      attribute :color, Lutaml::Model::Type::String
+      attribute :finish, Lutaml::Model::Type::String
+    end
+
+    class Vase < Lutaml::Model::Serializable
+      attribute :height, Lutaml::Model::Type::Float
+      attribute :diameter, Lutaml::Model::Type::Float
+      attribute :glaze, Glaze
+      attribute :materials, Lutaml::Model::Type::String, collection: true
+    end
+  end
+
+  describe ".generate" do
+    it "generates a JSON schema for nested Serialize objects" do
+      schema = described_class.generate(SchemaGeneration::Vase,
+                                        id: "https://example.com/vase.schema.json", description: "A vase schema", pretty: true)
+
+      expected_schema = <<~JSON.chomp
+        {
+          "$schema": "https://json-schema.org/draft/2020-12/schema",
+          "$id": "https://example.com/vase.schema.json",
+          "description": "A vase schema",
+          "$ref": "#/$defs/SchemaGeneration::Vase",
+          "$defs": {
+            "SchemaGeneration::Vase": {
+              "type": "object",
+              "properties": {
+                "height": {
+                  "type": "number"
+                },
+                "diameter": {
+                  "type": "number"
+                },
+                "glaze": {
+                  "$ref": "#/$defs/SchemaGeneration::Glaze"
+                },
+                "materials": {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                }
+              },
+              "required": [
+                "height",
+                "diameter",
+                "glaze",
+                "materials"
+              ]
+            },
+            "SchemaGeneration::Glaze": {
+              "type": "object",
+              "properties": {
+                "color": {
+                  "type": "string"
+                },
+                "finish": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "color",
+                "finish"
+              ]
+            }
+          }
+        }
+      JSON
+
+      expect(schema).to eq(expected_schema)
+    end
+  end
+end

data/spec/lutaml/model/schema/relaxng_schema_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+require "lutaml/model/schema"
+
+RSpec.describe Lutaml::Model::Schema::RelaxngSchema do
+  module SchemaGeneration
+    class Glaze < Lutaml::Model::Serializable
+      attribute :color, Lutaml::Model::Type::String
+      attribute :finish, Lutaml::Model::Type::String
+    end
+
+    class Vase < Lutaml::Model::Serializable
+      attribute :height, Lutaml::Model::Type::Float
+      attribute :diameter, Lutaml::Model::Type::Float
+      attribute :glaze, Glaze
+      attribute :materials, Lutaml::Model::Type::String, collection: true
+    end
+  end
+
+  describe ".generate" do
+    it "generates a RELAX NG schema for nested Serialize objects" do
+      schema = described_class.generate(SchemaGeneration::Vase, pretty: true)
+
+      expected_schema = <<~RELAXNG
+        <?xml version="1.0" encoding="UTF-8"?>
+        <grammar xmlns="http://relaxng.org/ns/structure/1.0">
+          <start>
+            <ref name="SchemaGeneration::Vase"/>
+          </start>
+          <define name="SchemaGeneration::Vase">
+            <element name="SchemaGeneration::Vase">
+              <element name="height">
+                <data type="float"/>
+              </element>
+              <element name="diameter">
+                <data type="float"/>
+              </element>
+              <ref name="SchemaGeneration::Glaze"/>
+              <zeroOrMore>
+                <element name="materials">
+                  <data type="string"/>
+                </element>
+              </zeroOrMore>
+            </element>
+          </define>
+          <define name="SchemaGeneration::Glaze">
+            <element name="SchemaGeneration::Glaze">
+              <element name="color">
+                <data type="string"/>
+              </element>
+              <element name="finish">
+                <data type="string"/>
+              </element>
+            </element>
+          </define>
+        </grammar>
+      RELAXNG
+      expect(schema).to eq(expected_schema)
+    end
+  end
+end

data/spec/lutaml/model/schema/xsd_schema_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+require "lutaml/model/schema"
+
+RSpec.describe Lutaml::Model::Schema::XsdSchema do
+  module SchemaGeneration
+    class Glaze < Lutaml::Model::Serializable
+      attribute :color, Lutaml::Model::Type::String
+      attribute :finish, Lutaml::Model::Type::String
+    end
+
+    class Vase < Lutaml::Model::Serializable
+      attribute :height, Lutaml::Model::Type::Float
+      attribute :diameter, Lutaml::Model::Type::Float
+      attribute :glaze, Glaze
+      attribute :materials, Lutaml::Model::Type::String, collection: true
+    end
+  end
+
+  describe ".generate" do
+    it "generates an XSD schema for nested Serialize objects" do
+      schema = described_class.generate(SchemaGeneration::Vase, pretty: true)
+
+      expected_schema = <<~XSD
+        <?xml version="1.0" encoding="UTF-8"?>
+        <schema xmlns="http://www.w3.org/2001/XMLSchema">
+          <element name="SchemaGeneration::Vase">
+            <complexType>
+              <sequence>
+                <element name="height" type="xs:float"/>
+                <element name="diameter" type="xs:float"/>
+                <element name="glaze">
+                  <complexType>
+                    <sequence>
+                      <element name="color" type="xs:string"/>
+                      <element name="finish" type="xs:string"/>
+                    </sequence>
+                  </complexType>
+                </element>
+                <element name="materials" minOccurs="0" maxOccurs="unbounded">
+                  <complexType>
+                    <sequence>
+                      <element name="item" type="xs:string"/>
+                    </sequence>
+                  </complexType>
+                </element>
+              </sequence>
+            </complexType>
+          </element>
+        </schema>
+      XSD
+
+      expect(schema).to eq(expected_schema)
+    end
+  end
+end

data/spec/lutaml/model/schema/yaml_schema_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+require "lutaml/model/schema"
+
+RSpec.describe Lutaml::Model::Schema::YamlSchema do
+  module SchemaGeneration
+    class Glaze < Lutaml::Model::Serializable
+      attribute :color, Lutaml::Model::Type::String
+      attribute :finish, Lutaml::Model::Type::String
+    end
+
+    class Vase < Lutaml::Model::Serializable
+      attribute :height, Lutaml::Model::Type::Float
+      attribute :diameter, Lutaml::Model::Type::Float
+      attribute :glaze, Glaze
+      attribute :materials, Lutaml::Model::Type::String, collection: true
+    end
+  end
+
+  describe ".generate" do
+    it "generates a YAML schema for nested Serialize objects" do
+      schema = described_class.generate(SchemaGeneration::Vase)
+
+      expected_schema = <<~YAML
+        ---
+        type: map
+        mapping:
+          height:
+            type: float
+          diameter:
+            type: float
+          glaze:
+            type: map
+            mapping:
+              color:
+                type: str
+              finish:
+                type: str
+          materials:
+            type: seq
+            sequence:
+            - type: str
+      YAML
+
+      expect(schema).to eq(expected_schema)
+    end
+  end
+end