lutaml-model 0.3.24 → 0.3.26

data/spec/address_spec.rb

@@ -0,0 +1,170 @@
+require "spec_helper"
+require_relative "fixtures/address"
+require_relative "fixtures/person"
+
+RSpec.describe Address do
+  let(:person1) do
+    {
+      first_name: "Tom",
+      last_name: "Warren",
+      age: 40,
+      height: 5.8,
+      birthdate: Date.new(1980, 2, 15),
+      last_login: "1980-02-15T10:00:00Z",
+      wakeup_time: "07:30:00",
+      active: true,
+    }
+  end
+  let(:person2) do
+    {
+      first_name: "Jack",
+      last_name: "Warren",
+      age: 35,
+      height: 5.9,
+      birthdate: Date.new(1985, 5, 20),
+      last_login: "1985-05-20T09:00:00Z",
+      wakeup_time: "06:45:00",
+      active: false,
+    }
+  end
+  let(:attributes) do
+    {
+      country: "USA",
+      post_code: "01001",
+      person: [person1, person2],
+    }
+  end
+  let(:address) { described_class.new(attributes) }
+
+  it "serializes to JSON with a collection of persons" do
+    expected_json = {
+      country: "USA",
+      postCode: "01001",
+      person: [
+        {
+          firstName: "Tom",
+          lastName: "Warren",
+          age: 40,
+          height: 5.8,
+          birthdate: "1980-02-15",
+          lastLogin: "1980-02-15T10:00:00+00:00",
+          wakeupTime: "07:30:00",
+          active: true,
+        },
+        {
+          firstName: "Jack",
+          lastName: "Warren",
+          age: 35,
+          height: 5.9,
+          birthdate: "1985-05-20",
+          lastLogin: "1985-05-20T09:00:00+00:00",
+          wakeupTime: "06:45:00",
+          active: false,
+        },
+      ],
+    }.to_json
+
+    expect(address.to_json).to eq(expected_json)
+  end
+
+  it "deserializes from JSON with a collection of persons" do
+    json = {
+      country: "USA",
+      postCode: "01001",
+      person: [
+        {
+          firstName: "Tom",
+          lastName: "Warren",
+          age: 40,
+          height: 5.8,
+          birthdate: "1980-02-15",
+          lastLogin: "1980-02-15T10:00:00Z",
+          wakeupTime: "07:30:00",
+          active: true,
+        },
+        {
+          firstName: "Jack",
+          lastName: "Warren",
+          age: 35,
+          height: 5.9,
+          birthdate: "1985-05-20",
+          lastLogin: "1985-05-20T09:00:00Z",
+          wakeupTime: "06:45:00",
+          active: false,
+        },
+      ],
+    }.to_json
+
+    address_from_json = described_class.from_json(json)
+    expect(address_from_json.country).to eq("USA")
+    expect(address_from_json.post_code).to eq("01001")
+    expect(address_from_json.person.first.first_name).to eq("Tom")
+    expect(address_from_json.person.last.first_name).to eq("Jack")
+  end
+
+  it "serializes to XML with a collection of persons" do
+    expected_xml = <<~XML
+      <Address xmlns:p="http://example.com/person" xmlns:nsp1="http://example.com/nsp1">
+        <Country>USA</Country>
+        <PostCode>01001</PostCode>
+        <p:Person>
+          <nsp1:FirstName>Tom</nsp1:FirstName>
+          <nsp1:LastName>Warren</nsp1:LastName>
+          <p:Age>40</p:Age>
+          <p:Height>5.8</p:Height>
+          <p:Birthdate>1980-02-15</p:Birthdate>
+          <p:LastLogin>1980-02-15T10:00:00+00:00</p:LastLogin>
+          <p:WakeupTime>07:30:00</p:WakeupTime>
+          <p:Active>true</p:Active>
+        </p:Person>
+        <p:Person>
+          <nsp1:FirstName>Jack</nsp1:FirstName>
+          <nsp1:LastName>Warren</nsp1:LastName>
+          <p:Age>35</p:Age>
+          <p:Height>5.9</p:Height>
+          <p:Birthdate>1985-05-20</p:Birthdate>
+          <p:LastLogin>1985-05-20T09:00:00+00:00</p:LastLogin>
+          <p:WakeupTime>06:45:00</p:WakeupTime>
+          <p:Active>false</p:Active>
+        </p:Person>
+      </Address>
+    XML
+
+    expect(address.to_xml).to be_equivalent_to(expected_xml)
+  end
+
+  it "deserializes from XML with a collection of persons" do
+    xml = <<~XML
+      <Address xmlns:p="http://example.com/person" xmlns:nsp1="http://example.com/nsp1">
+        <Country>USA</Country>
+        <PostCode>01001</PostCode>
+        <Person>
+          <nsp1:FirstName>Tom</nsp1:FirstName>
+          <nsp1:LastName>Warren</nsp1:LastName>
+          <Age>40</Age>
+          <Height>5.8</Height>
+          <Birthdate>1980-02-15</Birthdate>
+          <LastLogin>1980-02-15T10:00:00Z</LastLogin>
+          <WakeupTime>07:30:00</WakeupTime>
+          <Active>true</Active>
+        </Person>
+        <Person>
+          <nsp1:FirstName>Jack</nsp1:FirstName>
+          <nsp1:LastName>Warren</nsp1:LastName>
+          <Age>35</Age>
+          <Height>5.9</Height>
+          <Birthdate>1985-05-20</Birthdate>
+          <LastLogin>1985-05-20T09:00:00Z</LastLogin>
+          <WakeupTime>06:45:00</WakeupTime>
+          <Active>false</Active>
+        </Person>
+      </Address>
+    XML
+
+    address_from_xml = described_class.from_xml(xml)
+    expect(address_from_xml.country).to eq("USA")
+    expect(address_from_xml.post_code).to eq("01001")
+    expect(address_from_xml.person.first.first_name).to eq("Tom")
+    expect(address_from_xml.person.last.first_name).to eq("Jack")
+  end
+end

data/spec/fixtures/address.rb

@@ -0,0 +1,33 @@
+require "lutaml/model"
+require_relative "person"
+
+class Address < Lutaml::Model::Serializable
+  attribute :country, Lutaml::Model::Type::String
+  attribute :post_code, Lutaml::Model::Type::String
+  attribute :person, Person, collection: true
+
+  json do
+    map "country", to: :country
+    map "postCode", to: :post_code
+    map "person", to: :person
+  end
+
+  xml do
+    root "Address"
+    map_element "Country", to: :country
+    map_element "PostCode", to: :post_code
+    map_element "Person", to: :person
+  end
+
+  yaml do
+    map "country", to: :country
+    map "postCode", to: :post_code
+    map "person", to: :person
+  end
+
+  toml do
+    map "country", to: :country
+    map "post_code", to: :post_code
+    map "person", to: :person
+  end
+end

data/spec/fixtures/person.rb

@@ -0,0 +1,73 @@
+require "lutaml/model"
+
+class Person < Lutaml::Model::Serializable
+  attribute :first_name, Lutaml::Model::Type::String
+  attribute :last_name, Lutaml::Model::Type::String
+  attribute :age, Lutaml::Model::Type::Integer
+  attribute :height, Lutaml::Model::Type::Float
+  attribute :birthdate, Lutaml::Model::Type::Date
+  attribute :last_login, Lutaml::Model::Type::DateTime
+  attribute :wakeup_time, Lutaml::Model::Type::TimeWithoutDate
+  attribute :active, Lutaml::Model::Type::Boolean
+
+  xml do
+    root "Person"
+    namespace "http://example.com/person", "p"
+
+    map_element "FirstName",
+                to: :first_name,
+                namespace: "http://example.com/nsp1",
+                prefix: "nsp1"
+    map_element "LastName",
+                to: :last_name,
+                namespace: "http://example.com/nsp1",
+                prefix: "nsp1"
+    map_element "Age", to: :age
+    map_element "Height", to: :height
+    map_element "Birthdate", to: :birthdate
+    map_element "LastLogin", to: :last_login
+    map_element "WakeupTime", to: :wakeup_time
+    map_element "Active", to: :active
+  end
+
+  json do
+    map "firstName", to: :first_name
+    map "lastName", to: :last_name
+    map "age", to: :age
+    map "height", to: :height
+    map "birthdate", to: :birthdate
+    map "lastLogin", to: :last_login
+    map "wakeupTime", to: :wakeup_time
+    map "active", to: :active
+  end
+
+  yaml do
+    map "firstName", to: :first_name
+    map "lastName", with: { to: :yaml_from_last_name, from: :yaml_to_last_name }
+    map "age", to: :age
+    map "height", to: :height
+    map "birthdate", to: :birthdate
+    map "lastLogin", to: :last_login
+    map "wakeupTime", to: :wakeup_time
+    map "active", to: :active
+  end
+
+  toml do
+    map "first_name", to: :first_name
+    map "last_name", to: :last_name
+    map "age", to: :age
+    map "height", to: :height
+    map "birthdate", to: :birthdate
+    map "last_login", to: :last_login
+    map "wakeup_time", to: :wakeup_time
+    map "active", to: :active
+  end
+
+  def yaml_from_last_name(model, doc)
+    doc["lastName"] = model.last_name
+  end
+
+  def yaml_to_last_name(model, value)
+    model.last_name = value
+  end
+end

data/spec/fixtures/sample_model.rb

@@ -0,0 +1,40 @@
+require "lutaml/model"
+
+class SampleModelTag < Lutaml::Model::Serializable
+  attribute :text, :string, default: -> { "" }
+
+  xml do
+    root "Tag"
+    map_content to: :text
+  end
+end
+
+class SampleModel < Lutaml::Model::Serializable
+  attribute :name, :string, default: -> { "Anonymous" }
+  attribute :age, :integer, default: -> { 18 }
+  attribute :balance, :decimal, default: -> { BigDecimal("0.0") }
+  attribute :tags, SampleModelTag, collection: true
+  attribute :preferences, :hash, default: -> { { notifications: true } }
+  attribute :status, :string, default: -> { "active" }
+  attribute :large_number, :integer, default: -> { 0 }
+  attribute :email, :string, default: -> { "example@example.com" }
+  attribute :role, :string, values: %w[user admin guest], default: -> { "user" }
+
+  xml do
+    root "SampleModel"
+    map_element "Name", to: :name
+    map_element "Age", to: :age
+    map_element "Balance", to: :balance
+    map_element "Tags", to: :tags
+    map_element "Preferences", to: :preferences
+    map_element "Status", to: :status
+    map_element "LargeNumber", to: :large_number
+    map_element "Email", to: :email
+    map_element "Role", to: :role
+  end
+
+  yaml do
+    map "name", to: :name
+    map "age", to: :age
+  end
+end

data/spec/fixtures/vase.rb

@@ -0,0 +1,38 @@
+require "lutaml/model"
+
+class Vase < Lutaml::Model::Serializable
+  attribute :height, Lutaml::Model::Type::Float
+  attribute :diameter, Lutaml::Model::Type::Float
+  attribute :material, Lutaml::Model::Type::String
+  attribute :manufacturer, Lutaml::Model::Type::String
+
+  json do
+    map "height", to: :height
+    map "diameter", to: :diameter
+    map "material", to: :material
+    map "manufacturer", to: :manufacturer
+  end
+
+  yaml do
+    map "height", to: :height
+    map "diameter", to: :diameter
+    map "material", to: :material
+    map "manufacturer", to: :manufacturer
+  end
+
+  toml do
+    map "height", to: :height
+    map "diameter", to: :diameter
+    map "material", to: :material
+    map "manufacturer", to: :manufacturer
+  end
+
+  xml do
+    root "vase"
+    namespace "https://example.com/vase/1.0"
+    map_element "height", to: :height
+    map_element "diameter", to: :diameter
+    map_element "material", to: :material
+    map_attribute "manufacturer", to: :manufacturer
+  end
+end

data/spec/fixtures/xml/special_char.xml

@@ -0,0 +1,13 @@
+<article>
+  <back>
+    <ref-list>
+      <ref>
+        <element-citation>
+          <source>Continuity of care: report of a scoping exercise for
+            the national co-ordinating centre for NHS Service Delivery and
+            Organisation R&#x0026;D (NCCSDO), Summer 2000</source>
+        </element-citation>
+      </ref>
+    </ref-list>
+  </back>
+</article>

data/spec/lutaml/model/attribute_spec.rb

@@ -0,0 +1,139 @@
+require "spec_helper"
+require "lutaml/model"
+require "pathname"
+
+RSpec.describe Lutaml::Model::Attribute do
+  subject(:name_attr) do
+    described_class.new("name", :string)
+  end
+
+  let(:test_record_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :age, :integer
+      attribute :image, :string
+    end
+  end
+
+  before do
+    stub_const("TestRecord", test_record_class)
+  end
+
+  it "cast to integer when assigning age" do
+    obj = TestRecord.new
+
+    expect { obj.age = "20" }.to change { obj.age }.from(nil).to(20)
+  end
+
+  it "cast to string when assigning image file" do
+    obj = TestRecord.new
+
+    expect { obj.image = Pathname.new("avatar.png") }
+      .to change { obj.image }
+      .from(nil)
+      .to("avatar.png")
+  end
+
+  describe "#validate_options!" do
+    let(:validate_options) { name_attr.method(:validate_options!) }
+
+    Lutaml::Model::Attribute::ALLOWED_OPTIONS.each do |option|
+      it "return true if option is `#{option}`" do
+        expect(validate_options.call({ option => "value" })).to be(true)
+      end
+    end
+
+    it "raise exception if option is not allowed" do
+      expect do
+        validate_options.call({ foo: "bar" })
+      end.to raise_error(StandardError, "Invalid options given for `name` [:foo]")
+    end
+
+    it "raise exception if pattern is given with non string type" do
+      age_attr = described_class.new("age", :integer)
+
+      expect do
+        age_attr.send(:validate_options!, { pattern: /[A-Za-z ]/ })
+      end.to raise_error(
+        StandardError,
+        "Invalid option `pattern` given for `age`, `pattern` is only allowed for :string type",
+      )
+    end
+  end
+
+  describe "#validate_type!" do
+    let(:validate_type) { name_attr.method(:validate_type!) }
+
+    it "return true if type is a class" do
+      expect(validate_type.call(TestRecord)).to be(true)
+    end
+
+    it "return true if type is a valid symbol" do
+      expect(validate_type.call(:string)).to be(true)
+    end
+
+    it "return true if type is a valid string" do
+      expect(validate_type.call("String")).to be(true)
+    end
+
+    it "raise exception if type is invalid symbol" do
+      expect do
+        validate_type.call(:foo)
+      end.to raise_error(StandardError, "Unknown Lutaml::Model::Type: foo")
+    end
+
+    it "raise exception if type is invalid string" do
+      expect do
+        validate_type.call("foo")
+      end.to raise_error(StandardError, "Unknown Lutaml::Model::Type: foo")
+    end
+  end
+
+  describe "#cast_type!" do
+    it "cast :string to Lutaml::Model::Type::String" do
+      expect(name_attr.cast_type!(:string)).to eq(Lutaml::Model::Type::String)
+    end
+
+    it "cast :integer to Lutaml::Model::Type::Integer" do
+      expect(name_attr.cast_type!(:integer)).to eq(Lutaml::Model::Type::Integer)
+    end
+
+    it "raises ArgumentError on unknown type" do
+      expect { name_attr.cast_type!(:foobar) }
+        .to raise_error(ArgumentError, "Unknown Lutaml::Model::Type: foobar")
+    end
+  end
+
+  describe "#default?" do
+    context "when default is not set" do
+      let(:attribute) { described_class.new("name", :string) }
+
+      it { expect(attribute.default).to be_nil }
+    end
+
+    context "when default is set as a proc" do
+      it "returns the value" do
+        attribute = described_class.new("name", :string, default: -> { "John" })
+        expect(attribute.default).to eq("John")
+      end
+
+      it "returns the value casted to correct type" do
+        file = Pathname.new("avatar.png")
+        attribute = described_class.new("image", :string, default: -> { file })
+
+        expect(attribute.default).to eq("avatar.png")
+      end
+    end
+
+    context "when default is set as value" do
+      it "returns the value" do
+        attribute = described_class.new("name", :string, default: "John Doe")
+        expect(attribute.default).to eq("John Doe")
+      end
+
+      it "returns the value casted to correct type" do
+        attribute = described_class.new("age", :integer, default: "24")
+        expect(attribute.default).to eq(24)
+      end
+    end
+  end
+end