lutaml-model 0.7.1 → 0.7.7

data/spec/lutaml/model/register_spec.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+module RegisterSpec
+  class CustomString < Lutaml::Model::Type::String; end
+  class CustomInteger < Lutaml::Model::Type::Integer; end
+
+  Lutaml::Model::Type.register(:custom_string, CustomString)
+
+  class Address < Lutaml::Model::Serializable
+    attribute :location, :string
+    attribute :postal_code, :custom_string
+  end
+end
+
+RSpec.describe Lutaml::Model::Register do
+  describe "#initialize" do
+    it "initializes with id" do
+      register = described_class.new(:v1)
+      expect(register.id).to eq(:v1)
+      expect(register.models).to eq({})
+    end
+  end
+
+  describe "#register_model" do
+    let(:v1_register) { described_class.new(:v1) }
+
+    before do
+      v1_register.register_model(RegisterSpec::CustomString, id: :custom_string)
+      v1_register.register_model(RegisterSpec::CustomInteger, id: :custom_integer)
+    end
+
+    it "registers model with explicit id" do
+      expect(v1_register.models[:custom_string]).to be_nil
+    end
+
+    it "allows overriding an existing type" do
+      v1_register.register_model(Lutaml::Model::Type::String, id: :custom_string)
+      expect(v1_register.models[:custom_string]).to be_nil
+    end
+
+    it "registers serializable class" do
+      v1_register.register_model(RegisterSpec::Address, id: :address)
+      expect(v1_register.models[:address]).to eq(RegisterSpec::Address)
+    end
+
+    it "registers model without explicit id" do
+      stub_const("TestModel", Class.new(Lutaml::Model::Serializable))
+      v1_register.register_model(TestModel)
+      expect(v1_register.models[:test_model]).to eq(TestModel)
+    end
+  end
+
+  describe "#resolve" do
+    let(:v1_register) { described_class.new(:v1) }
+
+    before do
+      v1_register.register_model(RegisterSpec::Address, id: :address)
+    end
+
+    it "finds registered class by string representation" do
+      expect(v1_register.resolve("RegisterSpec::Address")).to eq(RegisterSpec::Address)
+    end
+
+    it "returns nil for unregistered class" do
+      expect(v1_register.resolve("UnknownClass")).to be_nil
+    end
+  end
+
+  describe "#get_class" do
+    let(:v1_register) { described_class.new(:v1) }
+
+    before do
+      v1_register.register_model(Lutaml::Model::Type::String, id: :custom_type)
+    end
+
+    it "returns registered class by key" do
+      expect(v1_register.get_class(:custom_type)).to eq(Lutaml::Model::Type::String)
+    end
+
+    it "returns class by string using constant lookup" do
+      expect(v1_register.get_class("String")).to eq(Lutaml::Model::Type::String)
+    end
+
+    it "returns class by symbol using Type.lookup" do
+      allow(Lutaml::Model::Type).to receive(:lookup).with(:String).and_return(Lutaml::Model::Type::String)
+      expect(v1_register.get_class(:String)).to eq(Lutaml::Model::Type::String)
+    end
+
+    it "returns class directly if class is provided" do
+      expect(v1_register.get_class(Lutaml::Model::Type::String)).to eq(Lutaml::Model::Type::String)
+    end
+
+    it "raises error for unsupported type" do
+      expect { v1_register.get_class(123) }.to raise_error(Lutaml::Model::UnknownTypeError)
+    end
+  end
+
+  describe "#register_model_tree" do
+    let(:v1_register) { described_class.new(:v1) }
+
+    context "when registering a valid model" do
+      let(:model_class) do
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :nested_address, RegisterSpec::Address
+        end
+      end
+
+      it "registers the model and its nested attributes" do
+        v1_register.register_model_tree(model_class)
+        expect(v1_register.models.values).to include(model_class)
+        expect(v1_register.models.values).to include(RegisterSpec::Address)
+      end
+    end
+  end
+
+  describe "#register_global_type_substitution" do
+    let(:v1_register) { described_class.new(:v1) }
+
+    it "registers a global type substitution" do
+      v1_register.register_global_type_substitution(from_type: :string, to_type: :text)
+      expect(v1_register.instance_variable_get(:@global_substitutions)).to include(string: :text)
+    end
+  end
+
+  describe "#register_attributes" do
+    let(:v1_register) { described_class.new(:v1) }
+    let(:model_class) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :nested_address, RegisterSpec::Address
+        attribute :string_attr, :string
+      end
+    end
+
+    it "registers non-builtin type attributes" do
+      attributes = model_class.attributes
+      v1_register.register_attributes(attributes)
+      expect(v1_register.models.values).to include(RegisterSpec::Address)
+    end
+
+    it "doesn't register built-in types" do
+      attributes = model_class.attributes
+      v1_register.register_attributes(attributes)
+      expect(v1_register.models.keys).not_to include(:string)
+    end
+  end
+end

data/spec/lutaml/model/root_mappings_spec.rb

@@ -283,15 +283,15 @@ RSpec.describe "RootMapping" do
     end
   end
 
-  describe Lutaml::Model::YamlAdapter::StandardYamlAdapter do
+  describe Lutaml::Model::Yaml::StandardAdapter do
     it_behaves_like "having root mappings", :yaml
   end
 
-  describe Lutaml::Model::JsonAdapter::StandardJsonAdapter do
+  describe Lutaml::Model::Json::StandardAdapter do
     it_behaves_like "having root mappings", :json
   end
 
-  describe Lutaml::Model::TomlAdapter::TomlRbAdapter do
+  describe Lutaml::Model::Toml::TomlRbAdapter do
     it_behaves_like "having root mappings", :toml
   end
 end

data/spec/lutaml/model/rule_value_extractor_spec.rb

@@ -0,0 +1,162 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::RuleValueExtractor do
+  subject(:extractor) do
+    described_class.new(rule, doc, format, attr, register, options)
+  end
+
+  let(:rule) { instance_double(Lutaml::Model::Jsonl::MappingRule) }
+  let(:doc) { { "name" => "Test", "value" => 123 } }
+  let(:format) { :json }
+  let(:attr) { instance_double(Lutaml::Model::Attribute) }
+  let(:register) { instance_double(Lutaml::Model::Register) }
+  let(:options) { {} }
+
+  describe "#call" do
+    context "when rule has single mapping" do
+      before do
+        allow(rule).to receive_messages(
+          multiple_mappings?: false,
+          name: "name",
+          root_mapping?: false,
+          raw_mapping?: false,
+        )
+      end
+
+      it "returns value for the rule name" do
+        expect(extractor.call).to eq("Test")
+      end
+    end
+
+    context "when rule has multiple mappings" do
+      before do
+        allow(rule).to receive_messages(
+          multiple_mappings?: true,
+          name: ["name", "value"],
+          root_mapping?: false,
+          raw_mapping?: false,
+        )
+      end
+
+      it "returns first initialized value" do
+        expect(extractor.call).to eq("Test")
+      end
+    end
+
+    context "when rule is root mapping" do
+      before do
+        allow(rule).to receive_messages(
+          multiple_mappings?: false,
+          name: "name",
+          root_mapping?: true,
+        )
+      end
+
+      it "returns the entire document" do
+        expect(extractor.call).to eq(doc)
+      end
+    end
+
+    context "when rule is raw mapping" do
+      before do
+        allow(rule).to receive_messages(
+          multiple_mappings?: false,
+          name: "name",
+          root_mapping?: false,
+          raw_mapping?: true,
+        )
+      end
+
+      it "converts document to specified format" do
+        expect(extractor.call).to eq('{"name":"Test","value":123}')
+      end
+    end
+
+    context "when value needs transformation" do
+      let(:options) do
+        {
+          key_mappings: instance_double(Lutaml::Model::KeyValueMappingRule, to_instance: :key),
+          value_mappings: instance_double(Lutaml::Model::KeyValueMappingRule, as_attribute: :value),
+        }
+      end
+
+      before do
+        allow(rule).to receive_messages(
+          multiple_mappings?: false,
+          name: "data",
+          root_mapping?: false,
+          raw_mapping?: false,
+        )
+      end
+
+      it "transforms hash values" do
+        doc = { "data" => { "test" => { "nested" => "value" } } }
+        extractor = described_class.new(rule, doc, format, attr, register, options)
+
+        expected = [{
+          "key" => "test",
+          "nested" => "value",
+        }]
+        expect(extractor.call).to eq(expected)
+      end
+
+      it "transforms simple values" do
+        doc = { "data" => { "test" => "value" } }
+        extractor = described_class.new(rule, doc, format, attr, register, options)
+
+        expected = [{
+          "key" => "test",
+          "value" => "value",
+        }]
+        expect(extractor.call).to eq(expected)
+      end
+    end
+
+    context "when value is not found" do
+      before do
+        allow(rule).to receive_messages(
+          multiple_mappings?: false,
+          name: "nonexistent",
+          root_mapping?: false,
+          raw_mapping?: false,
+        )
+        allow(attr).to receive(:default_set?).with(register).and_return(false)
+      end
+
+      it "returns uninitialized value" do
+        expect(extractor.call).to be_a(Lutaml::Model::UninitializedClass)
+      end
+    end
+
+    context "when attribute has default value" do
+      before do
+        allow(rule).to receive_messages(
+          multiple_mappings?: false,
+          name: "nonexistent",
+          root_mapping?: false,
+          raw_mapping?: false,
+        )
+        allow(attr).to receive(:default_set?).with(register).and_return(true)
+        allow(attr).to receive(:default).with(register).and_return("default_value")
+      end
+
+      it "returns default value" do
+        expect(extractor.call).to eq("default_value")
+      end
+    end
+  end
+
+  describe "#uninitialized_value" do
+    it "returns an instance of UninitializedClass" do
+      expect(
+        extractor.send(:uninitialized_value),
+      ).to be_a(Lutaml::Model::UninitializedClass)
+    end
+
+    it "returns the same instance for multiple calls" do
+      first_call = extractor.send(:uninitialized_value)
+      second_call = extractor.send(:uninitialized_value)
+      expect(first_call).to equal(second_call)
+    end
+  end
+end

data/spec/lutaml/model/schema/generator/definitions_collection_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/schema"
+
+module DefinitionsCollectionSpec
+  class Address < Lutaml::Model::Serializable
+    attribute :street, Lutaml::Model::Type::String
+  end
+
+  class HomeAddress < Address
+    attribute :is_home, Lutaml::Model::Type::Boolean
+  end
+
+  class WorkAddress < Address
+    attribute :company, Lutaml::Model::Type::String
+  end
+
+  class Person < Lutaml::Model::Serializable
+    attribute :name, Lutaml::Model::Type::String
+    attribute :age, Lutaml::Model::Type::Integer
+    attribute :address, Address, polymorphic: [HomeAddress, WorkAddress]
+  end
+end
+
+RSpec.describe Lutaml::Model::Schema::Generator::DefinitionsCollection do
+  let(:klass) { DefinitionsCollectionSpec::Person }
+  let(:register) { :def_collection }
+
+  before do
+    collection_register = Lutaml::Model::Register.new(register)
+    Lutaml::Model::GlobalRegister.register(collection_register)
+  end
+
+  describe ".from_class" do
+    subject(:collection) { described_class.from_class(klass) }
+
+    let(:all_classes) do
+      [
+        klass,
+        DefinitionsCollectionSpec::Address,
+        DefinitionsCollectionSpec::HomeAddress,
+        DefinitionsCollectionSpec::WorkAddress,
+      ]
+    end
+
+    it "creates a new DefinitionsCollection" do
+      expect(collection).to be_a(described_class)
+    end
+
+    it "generated definition" do
+      definition_class = Lutaml::Model::Schema::Generator::Definition
+      expect(collection.definitions.first).to be_a(definition_class)
+    end
+
+    it "initializes with the main class definition" do
+      expect(collection.definitions.size).to eq(all_classes.size)
+    end
+
+    it "includes definitions for main class and and all custom classes" do
+      definition_types = collection.definitions.map(&:type)
+      expect(definition_types).to include(*all_classes)
+    end
+  end
+
+  describe "#to_schema" do
+    subject(:schema) { collection.to_schema }
+
+    let(:collection) { described_class.from_class(klass) }
+
+    it "returns a hash" do
+      expect(schema).to be_a(Hash)
+    end
+
+    it "includes schema for all definitions" do
+      expect(schema.keys.size).to eq(collection.definitions.size)
+    end
+  end
+
+  describe "#add_definition" do
+    let(:collection) { described_class.new }
+    let(:definition) do
+      Lutaml::Model::Schema::Generator::Definition.new(String)
+    end
+
+    it "adds a definition to the collection" do
+      expect { collection.add_definition(definition) }
+        .to change { collection.definitions.size }.by(1)
+    end
+
+    it "accepts both Definition objects and classes" do
+      expect { collection.add_definition(String) }
+        .to change { collection.definitions.size }.by(1)
+    end
+  end
+
+  describe "#merge" do
+    let(:first_collection) do
+      described_class.new(
+        [
+          Lutaml::Model::Type::String,
+          Lutaml::Model::Type::Integer,
+        ],
+      )
+    end
+    let(:second_collection) do
+      described_class.new(
+        [
+          Lutaml::Model::Type::Float,
+          Lutaml::Model::Type::Boolean,
+        ],
+      )
+    end
+
+    it "merges two collections" do
+      first_collection.merge(second_collection)
+      expect(first_collection.definitions.size).to eq(4)
+    end
+  end
+end