lutaml-model 0.7.2 → 0.7.5

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