lutaml-model 0.3.24 → 0.3.26

data/spec/lutaml/model/serializable_spec.rb

@@ -0,0 +1,297 @@
+module SerializeableSpec
+  class TestModel
+    attr_accessor :name, :age
+
+    def initialize(name: nil, age: nil)
+      @name = name
+      @age = age
+    end
+  end
+
+  class TestModelMapper < Lutaml::Model::Serializable
+    model TestModel
+
+    attribute :name, Lutaml::Model::Type::String
+    attribute :age, Lutaml::Model::Type::String
+  end
+
+  class TestMapper < Lutaml::Model::Serializable
+    attribute :name, Lutaml::Model::Type::String
+    attribute :age, Lutaml::Model::Type::String
+
+    yaml do
+      map :na, to: :name
+      map :ag, to: :age
+    end
+  end
+
+  ### XML root mapping
+
+  class RecordDate < Lutaml::Model::Serializable
+    attribute :content, :string
+
+    xml do
+      root "recordDate"
+      map_content to: :content
+    end
+  end
+
+  class OriginInfo < Lutaml::Model::Serializable
+    attribute :date_issued, RecordDate, collection: true
+
+    xml do
+      root "originInfo"
+      map_element "dateIssued", to: :date_issued
+    end
+  end
+
+  ### Enumeration
+
+  class Ceramic < Lutaml::Model::Serializable
+    attribute :type, :string
+    attribute :firing_temperature, :integer
+  end
+
+  class CeramicCollection < Lutaml::Model::Serializable
+    attribute :featured_piece,
+              Ceramic,
+              values: [
+                Ceramic.new(type: "Porcelain", firing_temperature: 1300),
+                Ceramic.new(type: "Stoneware", firing_temperature: 1200),
+                Ceramic.new(type: "Earthenware", firing_temperature: 1000),
+              ]
+  end
+
+  class GlazeTechnique < Lutaml::Model::Serializable
+    attribute :name, :string, values: ["Celadon", "Raku", "Majolica"]
+  end
+end
+
+RSpec.describe Lutaml::Model::Serializable do
+  describe ".model" do
+    it "sets the model for the class" do
+      expect do
+        described_class.model(SerializeableSpec::TestModel)
+      end.to change(
+        described_class, :model
+      )
+        .from(nil)
+        .to(SerializeableSpec::TestModel)
+    end
+  end
+
+  describe ".attribute" do
+    subject(:mapper) { described_class.new }
+
+    it "adds the attribute and getter setter for that attribute" do
+      expect { described_class.attribute("foo", Lutaml::Model::Type::String) }
+        .to change { described_class.attributes.keys }.from([]).to(["foo"])
+        .and change { mapper.respond_to?(:foo) }.from(false).to(true)
+        .and change { mapper.respond_to?(:foo=) }.from(false).to(true)
+    end
+  end
+
+  describe ".hash_representation" do
+    context "when model is separate" do
+      let(:instance) do
+        SerializeableSpec::TestModel.new(name: "John", age: 18)
+      end
+
+      let(:expected_hash) do
+        {
+          "name" => "John",
+          "age" => "18",
+        }
+      end
+
+      it "return hash representation" do
+        generate_hash = SerializeableSpec::TestModelMapper.hash_representation(
+          instance, :yaml
+        )
+        expect(generate_hash).to eq(expected_hash)
+      end
+    end
+
+    context "when model is self" do
+      let(:instance) do
+        SerializeableSpec::TestMapper.new(name: "John", age: 18)
+      end
+
+      let(:expected_hash) do
+        {
+          na: "John",
+          ag: "18",
+        }
+      end
+
+      it "return hash representation" do
+        generate_hash = SerializeableSpec::TestMapper.hash_representation(
+          instance, :yaml
+        )
+        expect(generate_hash).to eq(expected_hash)
+      end
+    end
+  end
+
+  describe ".mappings_for" do
+    context "when mapping is defined" do
+      it "returns the defined mapping" do
+        actual_mappings = SerializeableSpec::TestMapper.mappings_for(:yaml).mappings
+
+        expect(actual_mappings[0].name).to eq(:na)
+        expect(actual_mappings[0].to).to eq(:name)
+
+        expect(actual_mappings[1].name).to eq(:ag)
+        expect(actual_mappings[1].to).to eq(:age)
+      end
+    end
+
+    context "when mapping is not defined" do
+      it "maps attributes to mappings" do
+        allow(SerializeableSpec::TestMapper.mappings).to receive(:[]).with(:yaml).and_return(nil)
+
+        actual_mappings = SerializeableSpec::TestMapper.mappings_for(:yaml).mappings
+
+        expect(actual_mappings[0].name).to eq("name")
+        expect(actual_mappings[0].to).to eq(:name)
+
+        expect(actual_mappings[1].name).to eq("age")
+        expect(actual_mappings[1].to).to eq(:age)
+      end
+    end
+  end
+
+  describe ".apply_child_mappings" do
+    let(:child_mappings) do
+      {
+        id: :key,
+        path: %i[path link],
+        name: %i[path name],
+      }
+    end
+
+    let(:hash) do
+      {
+        "foo" => {
+          "path" => {
+            "link" => "link one",
+            "name" => "one",
+          },
+        },
+        "abc" => {
+          "path" => {
+            "link" => "link two",
+            "name" => "two",
+          },
+        },
+        "hello" => {
+          "path" => {
+            "link" => "link three",
+            "name" => "three",
+          },
+        },
+      }
+    end
+
+    let(:expected_value) do
+      [
+        { id: "foo", path: "link one", name: "one" },
+        { id: "abc", path: "link two", name: "two" },
+        { id: "hello", path: "link three", name: "three" },
+      ]
+    end
+
+    it "generates hash based on child_mappings" do
+      expect(described_class.apply_child_mappings(hash,
+                                                  child_mappings)).to eq(expected_value)
+    end
+  end
+
+  describe "XML root name override" do
+    it "uses root name defined at the component class" do
+      record_date = SerializeableSpec::RecordDate.new(content: "2021-01-01")
+      expected_xml = "<recordDate>2021-01-01</recordDate>"
+      expect(record_date.to_xml).to eq(expected_xml)
+    end
+
+    it "uses mapped element name at the aggregating class, overriding root name" do
+      origin_info = SerializeableSpec::OriginInfo.new(date_issued: [SerializeableSpec::RecordDate.new(content: "2021-01-01")])
+      expected_xml = <<~XML
+        <originInfo><dateIssued>2021-01-01</dateIssued></originInfo>
+      XML
+      expect(origin_info.to_xml).to be_equivalent_to(expected_xml)
+    end
+  end
+
+  describe "String enumeration" do
+    context "when assigning an invalid value" do
+      it "raises an error after creation after validate" do
+        glaze = SerializeableSpec::GlazeTechnique.new(name: "Celadon")
+        glaze.name = "Tenmoku"
+        expect do
+          glaze.validate!
+        end.to raise_error(Lutaml::Model::ValidationError) do |error|
+          expect(error).to include(Lutaml::Model::InvalidValueError)
+          expect(error.error_messages).to include("name is `Tenmoku`, must be one of the following [Celadon, Raku, Majolica]")
+        end
+      end
+    end
+
+    context "when assigning a valid value" do
+      it "changes the value after creation" do
+        glaze = SerializeableSpec::GlazeTechnique.new(name: "Celadon")
+        glaze.name = "Raku"
+        expect(glaze.name).to eq("Raku")
+      end
+
+      it "assigns the value during creation" do
+        glaze = SerializeableSpec::GlazeTechnique.new(name: "Majolica")
+        expect(glaze.name).to eq("Majolica")
+      end
+    end
+  end
+
+  describe "Serializable object enumeration" do
+    context "when assigning an invalid value" do
+      it "raises ValidationError containing InvalidValueError after creation" do
+        glaze = SerializeableSpec::GlazeTechnique.new(name: "Celadon")
+        glaze.name = "Tenmoku"
+        expect do
+          glaze.validate!
+        end.to raise_error(Lutaml::Model::ValidationError) do |error|
+          expect(error).to include(Lutaml::Model::InvalidValueError)
+          expect(error.error_messages).to include(a_string_matching(/name is `Tenmoku`, must be one of the following/))
+        end
+      end
+
+      it "raises ValidationError containing InvalidValueError during creation" do
+        expect do
+          SerializeableSpec::GlazeTechnique.new(name: "Crystalline").validate!
+        end.to raise_error(Lutaml::Model::ValidationError) do |error|
+          expect(error).to include(Lutaml::Model::InvalidValueError)
+          expect(error.error_messages).to include(a_string_matching(/name is `Crystalline`, must be one of the following/))
+        end
+      end
+    end
+
+    context "when assigning a valid value" do
+      it "changes the value after creation" do
+        collection = SerializeableSpec::CeramicCollection.new(
+          featured_piece: SerializeableSpec::Ceramic.new(type: "Porcelain",
+                                                         firing_temperature: 1300),
+        )
+        collection.featured_piece = SerializeableSpec::Ceramic.new(type: "Stoneware",
+                                                                   firing_temperature: 1200)
+        expect(collection.featured_piece.type).to eq("Stoneware")
+      end
+
+      it "assigns the value during creation" do
+        collection = SerializeableSpec::CeramicCollection.new(
+          featured_piece: SerializeableSpec::Ceramic.new(type: "Earthenware",
+                                                         firing_temperature: 1000),
+        )
+        expect(collection.featured_piece.type).to eq("Earthenware")
+      end
+    end
+  end
+end

data/spec/lutaml/model/serializable_validation_spec.rb

@@ -0,0 +1,90 @@
+require "spec_helper"
+
+class TestSerializable < Lutaml::Model::Serializable
+  attribute :name, :string, values: ["Alice", "Bob", "Charlie"]
+  attribute :email, :string, pattern: /.*?\S+@.+\.\S+/
+  attribute :age, :integer, collection: 1..3
+
+  xml do
+    root "test"
+    map_element "name", to: :name
+    map_element "age", to: :age
+  end
+
+  json do
+    map "name", to: :name
+    map "age", to: :age
+  end
+
+  yaml do
+    map "name", to: :name
+    map "age", to: :age
+  end
+
+  toml do
+    map "name", to: :name
+    map "age", to: :age
+  end
+end
+
+RSpec.describe Lutaml::Model::Serializable do
+  let(:valid_instance) do
+    TestSerializable.new(name: "Alice", age: [30], email: "alice@gmail.com")
+  end
+
+  let(:invalid_instance) do
+    TestSerializable.new(name: "David", age: [25, 30, 35, 40], email: "david@gmail")
+  end
+
+  describe "serialization methods" do
+    it "does not raise validation errors when calling to_xml" do
+      expect { invalid_instance.to_xml }.not_to raise_error
+    end
+
+    it "does not raise validation errors when calling to_json" do
+      expect { invalid_instance.to_json }.not_to raise_error
+    end
+
+    it "does not raise validation errors when calling to_yaml" do
+      expect { invalid_instance.to_yaml }.not_to raise_error
+    end
+
+    it "does not raise validation errors when calling to_toml" do
+      expect { invalid_instance.to_toml }.not_to raise_error
+    end
+  end
+
+  describe "setting attributes" do
+    it "does not raise validation errors when setting valid attributes" do
+      expect { valid_instance.name = "Bob" }.not_to raise_error
+      expect { valid_instance.age = [25, 30] }.not_to raise_error
+    end
+
+    it "does not raise validation errors when setting invalid attributes" do
+      expect { invalid_instance.name = "David" }.not_to raise_error
+      expect { invalid_instance.age = [25, 30, 35, 40] }.not_to raise_error
+    end
+  end
+
+  describe "validate method" do
+    it "returns errors for invalid attributes" do
+      errors = invalid_instance.validate
+      expect(errors).not_to be_empty
+      expect(errors[0]).to be_a(Lutaml::Model::InvalidValueError)
+      expect(errors[1]).to be_a(Lutaml::Model::PatternNotMatchedError)
+      expect(errors[2]).to be_a(Lutaml::Model::CollectionCountOutOfRangeError)
+    end
+  end
+
+  describe "validate! method" do
+    it "raises ValidationError for invalid attributes" do
+      expect do
+        invalid_instance.validate!
+      end.to raise_error(Lutaml::Model::ValidationError)
+    end
+
+    it "does not raise ValidationError for valid attributes" do
+      expect { valid_instance.validate! }.not_to raise_error
+    end
+  end
+end

data/spec/lutaml/model/simple_model_spec.rb

@@ -0,0 +1,314 @@
+require "spec_helper"
+require "lutaml/model"
+
+module SimpleModel
+  class Address < Lutaml::Model::Serializable
+    attribute :street, :string
+    attribute :city, :string
+
+    xml do
+      root "address"
+      map_element "street", to: :street
+      map_element "city", to: :city
+    end
+
+    yaml do
+      map "street", to: :street
+      map "city", to: :city
+    end
+
+    json do
+      map "street", to: :street
+      map "city", to: :city
+    end
+
+    toml do
+      map "street", to: :street
+      map "city", to: :city
+    end
+  end
+
+  class Room < Lutaml::Model::Serializable
+    attribute :name, :string, default: -> { "Unnamed room" }
+    attribute :size, :integer
+
+    xml do
+      root "room"
+      map_element "name", to: :name
+      map_element "size", to: :size
+    end
+
+    yaml do
+      map "name", to: :name
+      map "size", to: :size
+    end
+
+    json do
+      map "name", to: :name
+      map "size", to: :size
+    end
+
+    toml do
+      map "name", to: :name
+      map "size", to: :size
+    end
+  end
+
+  class Building < Lutaml::Model::Serializable
+    attribute :name, :string, default: -> { "Unnamed building" }
+    attribute :address, Address
+    attribute :rooms, Room, collection: true
+
+    xml do
+      root "building"
+      map_attribute "name", to: :name
+      map_element "address", to: :address
+      map_element "room", to: :rooms
+    end
+
+    yaml do
+      map "name", to: :name
+      map "address", to: :address
+      map "rooms", to: :rooms
+    end
+
+    json do
+      map "name", to: :name
+      map "address", to: :address
+      map "rooms", to: :rooms
+    end
+
+    toml do
+      map "name", to: :name
+      map "address", to: :address
+      map "rooms", to: :rooms
+    end
+  end
+end
+
+RSpec.describe SimpleModel do
+  let(:address) do
+    SimpleModel::Address.new(street: "123 Main St", city: "Anytown")
+  end
+  let(:rooms) do
+    [SimpleModel::Room.new(name: "Conference Room", size: 30),
+     SimpleModel::Room.new(name: "Office", size: 20)]
+  end
+  let(:attributes) { { name: "Headquarters", address: address, rooms: rooms } }
+  let(:model) { SimpleModel::Building.new(attributes) }
+
+  let(:model_xml) do
+    <<~XML
+      <building name="Headquarters">
+        <address>
+          <street>123 Main St</street>
+          <city>Anytown</city>
+        </address>
+        <room>
+          <name>Conference Room</name>
+          <size>30</size>
+        </room>
+        <room>
+          <name>Office</name>
+          <size>20</size>
+        </room>
+      </building>
+    XML
+  end
+
+  let(:model_yaml) do
+    <<~YAML
+      ---
+      name: Headquarters
+      address:
+        street: 123 Main St
+        city: Anytown
+      rooms:
+      - name: Conference Room
+        size: 30
+      - name: Office
+        size: 20
+    YAML
+  end
+
+  let(:model_json) do
+    {
+      name: "Headquarters",
+      address: {
+        street: "123 Main St",
+        city: "Anytown",
+      },
+      rooms: [
+        {
+          name: "Conference Room",
+          size: 30,
+        },
+        {
+          name: "Office",
+          size: 20,
+        },
+      ],
+    }.to_json
+  end
+
+  let(:model_toml) do
+    <<~TOML
+      name = "Headquarters"
+      [address]
+      city = "Anytown"
+      street = "123 Main St"
+      [[rooms]]
+      name = "Conference Room"
+      size = 30
+      [[rooms]]
+      name = "Office"
+      size = 20
+    TOML
+  end
+
+  let(:model_yaml_missing_element) do
+    <<~YAML
+      ---
+      name: Headquarters
+      rooms:
+      - name: Conference Room
+        size: 30
+      - name: Office
+        size: 20
+    YAML
+  end
+
+  it "initializes with default values" do
+    default_model = SimpleModel::Building.new
+    expect(default_model.name).to eq("Unnamed building")
+    expect(default_model.address).to be_nil
+    expect(default_model.rooms).to eq([])
+  end
+
+  it "serializes to XML" do
+    expected_xml = model_xml.strip
+    expect(model.to_xml.strip).to eq(expected_xml)
+  end
+
+  it "deserializes from XML" do
+    sample = SimpleModel::Building.from_xml(model_xml)
+    expect(sample.name).to eq("Headquarters")
+    expect(sample.address.street).to eq("123 Main St")
+    expect(sample.address.city).to eq("Anytown")
+    expect(sample.rooms.size).to eq(2)
+    expect(sample.rooms[0].name).to eq("Conference Room")
+    expect(sample.rooms[0].size).to eq(30)
+    expect(sample.rooms[1].name).to eq("Office")
+    expect(sample.rooms[1].size).to eq(20)
+  end
+
+  it "round-trips XML" do
+    xml = model.to_xml
+    new_model = SimpleModel::Building.from_xml(xml)
+    expect(new_model.name).to eq(model.name)
+    expect(new_model.address.street).to eq(model.address.street)
+    expect(new_model.address.city).to eq(model.address.city)
+    expect(new_model.rooms.size).to eq(model.rooms.size)
+    model.rooms.each_with_index do |room, index|
+      expect(new_model.rooms[index].name).to eq(room.name)
+      expect(new_model.rooms[index].size).to eq(room.size)
+    end
+  end
+
+  it "serializes to YAML" do
+    expected_yaml = model_yaml.strip
+    expect(model.to_yaml.strip).to eq(expected_yaml)
+  end
+
+  it "deserializes from YAML" do
+    sample = SimpleModel::Building.from_yaml(model_yaml)
+    expect(sample.name).to eq("Headquarters")
+    expect(sample.address.street).to eq("123 Main St")
+    expect(sample.address.city).to eq("Anytown")
+    expect(sample.rooms.size).to eq(2)
+    expect(sample.rooms[0].name).to eq("Conference Room")
+    expect(sample.rooms[0].size).to eq(30)
+    expect(sample.rooms[1].name).to eq("Office")
+    expect(sample.rooms[1].size).to eq(20)
+  end
+
+  it "round-trips YAML" do
+    yaml = model.to_yaml
+    new_model = SimpleModel::Building.from_yaml(yaml)
+    expect(new_model.name).to eq(model.name)
+    expect(new_model.address.street).to eq(model.address.street)
+    expect(new_model.address.city).to eq(model.address.city)
+    expect(new_model.rooms.size).to eq(model.rooms.size)
+    model.rooms.each_with_index do |room, index|
+      expect(new_model.rooms[index].name).to eq(room.name)
+      expect(new_model.rooms[index].size).to eq(room.size)
+    end
+  end
+
+  it "serializes to YAML without the omitted element" do
+    model_without_address = SimpleModel::Building.new(name: "Headquarters",
+                                                      rooms: rooms)
+    expected_yaml = model_yaml_missing_element.strip
+    expect(model_without_address.to_yaml.strip).to eq(expected_yaml)
+  end
+
+  it "serializes to JSON" do
+    expected_json = model_json.strip
+    expect(model.to_json.strip).to eq(expected_json)
+  end
+
+  it "deserializes from JSON" do
+    sample = SimpleModel::Building.from_json(model_json)
+    expect(sample.name).to eq("Headquarters")
+    expect(sample.address.street).to eq("123 Main St")
+    expect(sample.address.city).to eq("Anytown")
+    expect(sample.rooms.size).to eq(2)
+    expect(sample.rooms[0].name).to eq("Conference Room")
+    expect(sample.rooms[0].size).to eq(30)
+    expect(sample.rooms[1].name).to eq("Office")
+    expect(sample.rooms[1].size).to eq(20)
+  end
+
+  it "round-trips JSON" do
+    json = model.to_json
+    new_model = SimpleModel::Building.from_json(json)
+    expect(new_model.name).to eq(model.name)
+    expect(new_model.address.street).to eq(model.address.street)
+    expect(new_model.address.city).to eq(model.address.city)
+    expect(new_model.rooms.size).to eq(model.rooms.size)
+    model.rooms.each_with_index do |room, index|
+      expect(new_model.rooms[index].name).to eq(room.name)
+      expect(new_model.rooms[index].size).to eq(room.size)
+    end
+  end
+
+  it "serializes to TOML" do
+    expected_toml = model_toml.strip
+    expect(model.to_toml.strip).to eq(expected_toml)
+  end
+
+  it "deserializes from TOML" do
+    sample = SimpleModel::Building.from_toml(model_toml)
+    expect(sample.name).to eq("Headquarters")
+    expect(sample.address.street).to eq("123 Main St")
+    expect(sample.address.city).to eq("Anytown")
+    expect(sample.rooms.size).to eq(2)
+    expect(sample.rooms[0].name).to eq("Conference Room")
+    expect(sample.rooms[0].size).to eq(30)
+    expect(sample.rooms[1].name).to eq("Office")
+    expect(sample.rooms[1].size).to eq(20)
+  end
+
+  it "round-trips TOML" do
+    toml = model.to_toml
+    new_model = SimpleModel::Building.from_toml(toml)
+    expect(new_model.name).to eq(model.name)
+    expect(new_model.address.street).to eq(model.address.street)
+    expect(new_model.address.city).to eq(model.address.city)
+    expect(new_model.rooms.size).to eq(model.rooms.size)
+    model.rooms.each_with_index do |room, index|
+      expect(new_model.rooms[index].name).to eq(room.name)
+      expect(new_model.rooms[index].size).to eq(room.size)
+    end
+  end
+end