lutaml-model 0.3.23 → 0.3.25

data/spec/lutaml/model/type_spec.rb

@@ -0,0 +1,276 @@
+# spec/lutaml/model/type_spec.rb
+require "spec_helper"
+require "bigdecimal"
+
+# Test classes for type registration scenarios
+class CustomType < Lutaml::Model::Type::Value
+  def self.cast(value)
+    value.to_s.upcase
+  end
+end
+
+class InvalidType
+  def self.cast(value)
+    value
+  end
+end
+
+RSpec.describe Lutaml::Model::Type do
+  describe "Type System" do
+    describe ".register and .lookup" do
+      context "with valid types" do
+        it "registers and looks up a custom type" do
+          described_class.register(:custom, CustomType)
+          expect(described_class.lookup(:custom)).to eq(CustomType)
+        end
+
+        it "allows overriding an existing type registration" do
+          described_class.register(:custom, CustomType)
+          replacement_type = Class.new(Lutaml::Model::Type::Value)
+          described_class.register(:custom, replacement_type)
+          expect(described_class.lookup(:custom)).to eq(replacement_type)
+        end
+      end
+
+      context "with invalid types" do
+        it "raises TypeError when registering non-Type::Value class" do
+          expect do
+            described_class.register(:invalid,
+                                     InvalidType)
+          end.to raise_error(Lutaml::Model::TypeError,
+                             /not a valid Lutaml::Model::Type::Value/)
+        end
+
+        it "raises UnknownTypeError when looking up unregistered type" do
+          expect do
+            described_class.lookup(:nonexistent)
+          end.to raise_error(
+            Lutaml::Model::UnknownTypeError, /Unknown type 'nonexistent'/
+          )
+        end
+      end
+    end
+
+    describe "Built-in Types" do
+      before do
+        described_class.register_builtin_types
+      end
+
+      after do
+        described_class.instance_variable_set(:@registry, nil)
+      end
+
+      let(:built_in_types) do
+        {
+          string: Lutaml::Model::Type::String,
+          integer: Lutaml::Model::Type::Integer,
+          float: Lutaml::Model::Type::Float,
+          date: Lutaml::Model::Type::Date,
+          time: Lutaml::Model::Type::Time,
+          date_time: Lutaml::Model::Type::DateTime,
+          time_without_date: Lutaml::Model::Type::TimeWithoutDate,
+          boolean: Lutaml::Model::Type::Boolean,
+          hash: Lutaml::Model::Type::Hash,
+        }
+      end
+
+      it "has all built-in types registered" do
+        built_in_types.each do |type_name, type_class|
+          puts described_class
+          expect(described_class.lookup(type_name)).to eq(type_class)
+        end
+      end
+
+      describe "Type Casting" do
+        let(:test_date) { Date.new(2024, 1, 1) }
+        let(:test_time) { Time.new(2024, 1, 1, 12, 0, 0) }
+        let(:test_date_time) { DateTime.new(2024, 1, 1, 12, 0, 0) }
+
+        {
+          Lutaml::Model::Type::String => { input: 123, expected: "123" },
+          Lutaml::Model::Type::Integer => { input: "123", expected: 123 },
+          Lutaml::Model::Type::Float => { input: "123.45", expected: 123.45 },
+          Lutaml::Model::Type::Date => { input: "2024-01-01",
+                                         expected: Date.new(2024, 1, 1) },
+          Lutaml::Model::Type::Time => { input: "2024-01-01T12:00:00",
+                                         expected_hour: 12 },
+          Lutaml::Model::Type::DateTime => { input: "2024-01-01T12:00:00",
+                                             expected: DateTime.new(2024, 1, 1,
+                                                                    12, 0, 0) },
+          Lutaml::Model::Type::Boolean => { input: "true", expected: true },
+          Lutaml::Model::Type::Hash => { input: { key: "value" },
+                                         expected: { key: "value" } },
+        }.each do |type_class, test_data|
+          it "correctly casts #{type_class}" do
+            result = type_class.cast(test_data[:input])
+            if test_data.key?(:expected_hour)
+              expect(result.hour).to eq(test_data[:expected_hour])
+            else
+              expect(result).to eq(test_data[:expected])
+            end
+          end
+        end
+
+        it "handles nil values gracefully" do
+          built_in_types.each_value do |type_class|
+            expect(type_class.cast(nil)).to be_nil
+          end
+        end
+      end
+    end
+
+    describe "Decimal Type" do
+      context "when BigDecimal is available" do
+        before do
+          require "bigdecimal"
+          described_class.register_builtin_types
+        end
+
+        it "registers and uses Decimal type" do
+          expect(described_class.lookup(:decimal)).to eq(Lutaml::Model::Type::Decimal)
+          expect(Lutaml::Model::Type::Decimal.cast("123.45")).to eq(BigDecimal("123.45"))
+        end
+
+        it "serializes decimal values correctly" do
+          value = BigDecimal("123.45")
+          expect(Lutaml::Model::Type::Decimal.serialize(value)).to eq("123.45")
+        end
+      end
+
+      context "when BigDecimal is not available" do
+        before do
+          Object.send(:remove_const, :BigDecimal) if defined?(BigDecimal)
+          $LOADED_FEATURES.delete_if { |path| path.include?("bigdecimal") }
+        end
+
+        after do
+          require "bigdecimal"
+        end
+
+        let(:decimal_class) { described_class.lookup(:decimal) }
+
+        it "raises TypeNotEnabledError when using Decimal type" do
+          expect do
+            described_class.lookup(:decimal).cast("123.45")
+          end.to raise_error(Lutaml::Model::TypeNotEnabledError)
+        end
+      end
+    end
+  end
+
+  describe "Type Usage in Models" do
+    class TypeTestModel < Lutaml::Model::Serializable
+      attribute :string_symbol, :string
+      attribute :string_class, Lutaml::Model::Type::String
+      attribute :integer_value, :integer
+      attribute :float_value, :float
+      attribute :date_value, :date
+      attribute :time_value, :time
+      attribute :time_without_date_value, :time_without_date
+      attribute :date_time_value, :date_time
+      attribute :boolean_value, :boolean
+      attribute :hash_value, :hash
+
+      xml do
+        root "test"
+        map_element "string_symbol", to: :string_symbol
+        map_element "string_class", to: :string_class
+        map_element "integer", to: :integer_value
+        map_element "float", to: :float_value
+        map_element "date", to: :date_value
+        map_element "time", to: :time_value
+        map_element "time_without_date", to: :time_without_date_value
+        map_element "date_time", to: :date_time_value
+        map_element "boolean", to: :boolean_value
+        map_element "hash", to: :hash_value
+      end
+    end
+
+    let(:test_instance) do
+      TypeTestModel.new(
+        string_symbol: "test",
+        string_class: "test",
+        integer_value: "123",
+        float_value: "123.45",
+        date_value: "2024-01-01",
+        time_value: "12:00:00",
+        time_without_date_value: "10:06:15",
+        date_time_value: "2024-01-01T12:00:00",
+        boolean_value: "true",
+        hash_value: { key: "value" },
+      )
+    end
+
+    describe "Type Casting in Models" do
+      it "correctly casts values using both symbol and class-based types" do
+        expect(test_instance.string_symbol).to eq("test")
+        expect(test_instance.string_class).to eq("test")
+        expect(test_instance.integer_value).to eq(123)
+        expect(test_instance.float_value).to eq(123.45)
+        expect(test_instance.date_value).to eq(Date.new(2024, 1, 1))
+        expect(test_instance.time_value.hour).to eq(12)
+        expect(test_instance.date_time_value).to eq(DateTime.new(2024, 1, 1,
+                                                                 12, 0, 0))
+        expect(test_instance.boolean_value).to be(true)
+        expect(test_instance.hash_value).to eq({ key: "value" })
+      end
+
+      it "produces identical results with symbol and class-based definitions" do
+        expect(test_instance.string_symbol).to eq(test_instance.string_class)
+      end
+    end
+
+    describe "Serialization" do
+      it "correctly serializes to XML" do
+        expected_xml = <<~XML
+          <test>
+            <string_symbol>test</string_symbol>
+            <string_class>test</string_class>
+            <integer>123</integer>
+            <float>123.45</float>
+            <date>2024-01-01</date>
+            <time>#{Time.parse('12:00:00').iso8601}</time>
+            <time_without_date>10:06:15</time_without_date>
+            <date_time>2024-01-01T12:00:00+00:00</date_time>
+            <boolean>true</boolean>
+            <hash>
+              <key>value</key>
+            </hash>
+          </test>
+        XML
+
+        expect(test_instance.to_xml).to be_equivalent_to(expected_xml)
+      end
+
+      it "correctly deserializes from XML" do
+        xml = <<~XML
+          <test>
+            <string_symbol>test</string_symbol>
+            <string_class>test</string_class>
+            <integer>123</integer>
+            <float>123.45</float>
+            <date>2024-01-01</date>
+            <time>12:00:00</time>
+            <time_without_date>10:06:15</time_without_date>
+            <date_time>2024-01-01T12:00:00</date_time>
+            <boolean>true</boolean>
+            <hash>
+              <key>value</key>
+            </hash>
+          </test>
+        XML
+
+        deserialized = TypeTestModel.from_xml(xml)
+        expect(deserialized.string_symbol).to eq("test")
+        expect(deserialized.string_class).to eq("test")
+        expect(deserialized.integer_value).to eq(123)
+        expect(deserialized.float_value).to eq(123.45)
+        expect(deserialized.date_value).to eq(Date.new(2024, 1, 1))
+        expect(deserialized.date_time_value).to eq(DateTime.new(2024, 1, 1, 12,
+                                                                0, 0))
+        expect(deserialized.boolean_value).to be(true)
+        expect(deserialized.hash_value).to eq({ "key" => "value" })
+      end
+    end
+  end
+end

data/spec/lutaml/model/utils_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper"
+require "lutaml/model/utils"
+
+RSpec.describe Lutaml::Model::Utils do
+  let(:utils) { described_class }
+
+  shared_examples "string conversion" do |method, examples|
+    describe ".#{method}" do
+      examples.each do |input, expected_output|
+        context "when input is #{input.nil? ? 'nil' : "'#{input}'"}" do
+          it "returns '#{expected_output}'" do
+            expect(utils.send(method, input)).to eq(expected_output)
+          end
+        end
+      end
+    end
+  end
+
+  camel_case_examples = {
+    "hello_world" => "HelloWorld",
+    "foo_bar_baz" => "FooBarBaz",
+    "" => "",
+    nil => "",
+    "hello_world/foo_bar_baz" => "HelloWorld::FooBarBaz",
+  }
+
+  classify_examples_extra = {
+    "hello_world::foo_bar_baz" => "HelloWorld::FooBarBaz",
+  }
+  classify_examples = camel_case_examples.merge(classify_examples_extra)
+
+  snake_case_examples = {
+    "HelloWorld" => "hello_world",
+    "FooBarBaz" => "foo_bar_baz",
+    "" => "",
+    nil => "",
+    "HelloWorld::FooBarBaz" => "hello_world/foo_bar_baz",
+  }
+
+  include_examples "string conversion", :camel_case, camel_case_examples
+  include_examples "string conversion", :classify, classify_examples
+  include_examples "string conversion", :snake_case, snake_case_examples
+
+  describe ".deep_dup" do
+    let(:original_hash) do
+      {
+        one: {
+          one_one: {
+            one_one1: "one",
+            one_one2: :two,
+          },
+          one_two: "12",
+        },
+      }
+    end
+
+    let(:duplicate_hash) { utils.deep_dup(original_hash) }
+
+    it "creates deep duplicate of hash" do
+      expect(original_hash).to eq(duplicate_hash)
+      expect(original_hash.object_id).not_to eq(duplicate_hash.object_id)
+
+      expect(original_hash[:one]).to eq(duplicate_hash[:one])
+      expect(original_hash[:one].object_id).not_to eq(duplicate_hash[:one].object_id)
+
+      expect(original_hash[:one][:one_one]).to eq(duplicate_hash[:one][:one_one])
+      expect(original_hash[:one][:one_one].object_id).not_to eq(duplicate_hash[:one][:one_one].object_id)
+
+      expect(original_hash[:one][:one_one][:one_one1]).to eq(duplicate_hash[:one][:one_one][:one_one1])
+      expect(original_hash[:one][:one_one][:one_one1].object_id).not_to eq(duplicate_hash[:one][:one_one][:one_one1].object_id)
+
+      # this is a symbol so the object_id will be same
+      expect(original_hash[:one][:one_one][:one_one2]).to eq(duplicate_hash[:one][:one_one][:one_one2])
+
+      expect(original_hash[:one][:one_two]).to eq(duplicate_hash[:one][:one_two])
+      expect(original_hash[:one][:one_two].object_id).not_to eq(duplicate_hash[:one][:one_two].object_id)
+    end
+  end
+end

data/spec/lutaml/model/validation_spec.rb

@@ -0,0 +1,83 @@
+# spec/lutaml/model/validation_spec.rb
+
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Validation do
+  class ValidationTestClass < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :age, :integer
+    attribute :email, :string, values: ["test@example.com", "user@example.com"]
+    attribute :tags, :string, collection: true
+    attribute :role, :string, collection: 1..3
+  end
+
+  let(:valid_instance) do
+    ValidationTestClass.new(
+      name: "John Doe",
+      age: 30,
+      email: "test@example.com",
+      tags: ["tag1", "tag2"],
+      role: ["admin"],
+    )
+  end
+
+  describe "#validate" do
+    it "returns an empty array for a valid instance" do
+      expect(valid_instance.validate).to be_empty
+    end
+
+    xit "returns errors for invalid integer value" do
+      instance = ValidationTestClass.new(age: "thirty", role: ["admin"])
+      errors = instance.validate
+      expect(errors).to include("Invalid value for attribute age: thirty")
+    end
+
+    it "returns errors for value not in allowed set" do
+      instance = ValidationTestClass.new(email: "invalid@example.com",
+                                         role: ["admin"])
+      expect do
+        instance.validate!
+      end.to raise_error(Lutaml::Model::ValidationError) do |error|
+        expect(error.error_messages.join("\n")).to include("email is `invalid@example.com`, must be one of the following [test@example.com, user@example.com]")
+      end
+    end
+
+    it "returns errors for invalid collection count" do
+      instance = ValidationTestClass.new(role: ["admin", "user", "manager",
+                                                "guest"])
+      expect do
+        instance.validate!
+      end.to raise_error(Lutaml::Model::ValidationError) do |error|
+        expect(error.error_messages.join("\n")).to include("role count is 4, must be between 1 and 3")
+      end
+    end
+
+    xit "returns multiple errors for multiple invalid attributes" do
+      instance = ValidationTestClass.new(name: "123", age: "thirty",
+                                         email: "invalid@example.com", role: [])
+      expect do
+        instance.validate!
+      end.to raise_error(Lutaml::Model::ValidationError) do |error|
+        expect(error.error_messages.join("\n")).to include("Invalid value for attribute age: thirty")
+        expect(error.error_messages.join("\n")).to include("email is `invalid@example.com`, must be one of the following [test@example.com, user@example.com]")
+        expect(error.error_messages.join("\n")).to include("role count is 0, must be between 1 and 3")
+      end
+    end
+  end
+
+  describe "#validate!" do
+    it "does not raise an error for a valid instance" do
+      expect { valid_instance.validate! }.not_to raise_error
+    end
+
+    xit "raises a ValidationError with all error messages for an invalid instance" do
+      instance = ValidationTestClass.new(name: "test", age: "thirty")
+      expect do
+        instance.validate!
+      end.to raise_error(Lutaml::Model::ValidationError) do |error|
+        expect(error.error_messages.join("\n")).to include("role count is 0, must be between 1 and 3")
+        expect(error.error_messages.join("\n")).to include("Invalid value for attribute age: thirty")
+      end
+    end
+  end
+end

data/spec/lutaml/model/with_child_mapping_spec.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module ChildMapping
+  class Schema < Lutaml::Model::Serializable
+    attribute :id, Lutaml::Model::Type::String
+    attribute :path, Lutaml::Model::Type::String
+    attribute :name, Lutaml::Model::Type::String
+  end
+
+  class ChildMappingClass < Lutaml::Model::Serializable
+    attribute :schemas, Schema, collection: true
+
+    json do
+      map "schemas", to: :schemas,
+                     child_mappings: {
+                       id: :key,
+                       path: %i[path link],
+                       name: %i[path name],
+                     }
+    end
+
+    yaml do
+      map "schemas", to: :schemas,
+                     child_mappings: {
+                       id: :key,
+                       path: %i[path link],
+                       name: %i[path name],
+                     }
+    end
+
+    toml do
+      map "schemas", to: :schemas,
+                     child_mappings: {
+                       id: :key,
+                       path: %i[path abc],
+                       name: %i[path name],
+                     }
+    end
+  end
+end
+
+RSpec.describe ChildMapping do
+  let(:mapper) { ChildMapping::ChildMappingClass }
+  let(:schema) { ChildMapping::Schema }
+
+  let(:hash) do
+    {
+      "schemas" => {
+        "foo" => {
+          "path" => {
+            "link" => "link one",
+            "name" => "one",
+          },
+        },
+        "abc" => {
+          "path" => {
+            "link" => "link two",
+            "name" => "two",
+          },
+        },
+        "hello" => {
+          "path" => {
+            "link" => "link three",
+            "name" => "three",
+          },
+        },
+      },
+    }
+  end
+
+  let(:expected_ids) { ["foo", "abc", "hello"] }
+  let(:expected_paths) { ["link one", "link two", "link three"] }
+  let(:expected_names) { ["one", "two", "three"] }
+
+  context "with json" do
+    let(:json) do
+      hash.to_json
+    end
+
+    describe ".from_json" do
+      it "create model according to json" do
+        instance = mapper.from_json(json)
+
+        expect(instance.schemas.count).to eq(3)
+        expect(instance.schemas.map(&:id)).to eq(expected_ids)
+        expect(instance.schemas.map(&:path)).to eq(expected_paths)
+        expect(instance.schemas.map(&:name)).to eq(expected_names)
+      end
+    end
+
+    describe ".to_json" do
+      it "converts objects to json" do
+        schema1 = schema.new(id: "foo", path: "link one", name: "one")
+        schema2 = schema.new(id: "abc", path: "link two", name: "two")
+        schema3 = schema.new(id: "hello", path: "link three", name: "three")
+
+        instance = mapper.new(schemas: [schema1, schema2, schema3])
+
+        expect(instance.to_json).to eq(json)
+      end
+    end
+  end
+
+  context "with yaml" do
+    let(:yaml) do
+      hash.to_yaml
+    end
+
+    describe ".from_yaml" do
+      it "create model according to yaml" do
+        instance = mapper.from_yaml(yaml)
+
+        expect(instance.schemas.count).to eq(3)
+        expect(instance.schemas.map(&:id)).to eq(expected_ids)
+        expect(instance.schemas.map(&:path)).to eq(expected_paths)
+        expect(instance.schemas.map(&:name)).to eq(expected_names)
+      end
+    end
+
+    describe ".to_yaml" do
+      it "converts objects to yaml" do
+        schema1 = schema.new(id: "foo", path: "link one", name: "one")
+        schema2 = schema.new(id: "abc", path: "link two", name: "two")
+        schema3 = schema.new(id: "hello", path: "link three", name: "three")
+
+        instance = mapper.new(schemas: [schema1, schema2, schema3])
+
+        expect(instance.to_yaml).to eq(yaml)
+      end
+    end
+  end
+
+  context "with toml" do
+    let(:toml) do
+      <<~TOML
+        [schemas.foo.path]
+        abc = "link one"
+        name = "one"
+        [schemas.abc.path]
+        abc = "link two"
+        name = "two"
+        [schemas.hello.path]
+        abc = "link three"
+        name = "three"
+      TOML
+    end
+
+    describe ".from_toml" do
+      it "create model according to toml" do
+        instance = mapper.from_toml(toml)
+
+        expect(instance.schemas.count).to eq(3)
+        expect(instance.schemas.map(&:id)).to eq(expected_ids)
+        expect(instance.schemas.map(&:path)).to eq(expected_paths)
+        expect(instance.schemas.map(&:name)).to eq(expected_names)
+      end
+    end
+
+    describe ".to_toml" do
+      it "converts objects to toml" do
+        schema1 = schema.new(id: "foo", path: "link one", name: "one")
+        schema2 = schema.new(id: "abc", path: "link two", name: "two")
+        schema3 = schema.new(id: "hello", path: "link three", name: "three")
+
+        instance = mapper.new(schemas: [schema1, schema2, schema3])
+
+        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)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require "spec_helper"
+require "nokogiri"
+require_relative "../../../../lib/lutaml/model/xml_adapter/nokogiri_adapter"
+
+RSpec.describe Lutaml::Model::XmlAdapter::NokogiriAdapter do
+  let(:xml_string) do
+    <<-XML
+      <root xmlns="http://example.com/default" xmlns:prefix="http://example.com/prefixed">
+        <prefix:child attr="value" prefix:attr1="prefixed_value">Text</prefix:child>
+      </root>
+    XML
+  end
+
+  let(:document) { described_class.parse(xml_string) }
+
+  context "when parsing XML with namespaces" do
+    let(:child) { document.root.children[1] }
+
+    it "parses the root element with default namespace" do
+      expect(document.root.name).to eq("root")
+      expect(document.root.namespace.uri).to eq("http://example.com/default")
+      expect(document.root.namespace.prefix).to be_nil
+    end
+
+    it "parses child element with prefixed namespace" do
+      expect(child.name).to eq("prefix:child")
+      expect(child.namespace.uri).to eq("http://example.com/prefixed")
+      expect(child.namespace.prefix).to eq("prefix")
+    end
+
+    it "parses attributes with and without namespaces" do
+      expect(child.attributes["attr"].value).to eq("value")
+      expect(child.attributes["attr"].namespace).to be_nil
+      expect(child.attributes["prefix:attr1"].value).to eq("prefixed_value")
+      expect(child.attributes["prefix:attr1"].namespace).to eq("http://example.com/prefixed")
+      expect(child.attributes["prefix:attr1"].namespace_prefix).to eq("prefix")
+    end
+  end
+
+  context "when generating XML with namespaces" do
+    it "generates XML with namespaces correctly" do
+      xml_output = document.to_xml
+      parsed_output = Nokogiri::XML(xml_output)
+
+      root = parsed_output.root
+      expect(root.name).to eq("root")
+      expect(root.namespace.href).to eq("http://example.com/default")
+
+      child = root.children[1]
+      expect(child.name).to eq("child")
+      expect(child.namespace.href).to eq("http://example.com/prefixed")
+      expect(child.attributes["attr"].value).to eq("value")
+      expect(child.attributes["attr1"].value).to eq("prefixed_value")
+    end
+  end
+end