lutaml-model 0.7.1 → 0.7.7

data/spec/lutaml/model/schema/yaml_schema_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 require "lutaml/model/schema"
 
-module SchemaGeneration
+module YamlSchemaSpec
   class Glaze < Lutaml::Model::Serializable
     attribute :color, Lutaml::Model::Type::String
     attribute :finish, Lutaml::Model::Type::String
@@ -13,35 +13,258 @@ module SchemaGeneration
     attribute :glaze, Glaze
     attribute :materials, Lutaml::Model::Type::String, collection: true
   end
+
+  class ChoiceModel < Lutaml::Model::Serializable
+    attribute :name, Lutaml::Model::Type::String
+    attribute :email, Lutaml::Model::Type::String
+    attribute :phone, Lutaml::Model::Type::String
+
+    choice(min: 1, max: 2) do
+      attribute :email, Lutaml::Model::Type::String
+      attribute :phone, Lutaml::Model::Type::String
+    end
+  end
+
+  class ValidationModel < Lutaml::Model::Serializable
+    attribute :name, Lutaml::Model::Type::String, values: %w[Alice Bob Charlie]
+    attribute :email, Lutaml::Model::Type::String, pattern: /.*?\S+@.+\.\S+/
+    attribute :age, Lutaml::Model::Type::Integer, collection: 1..3
+    attribute :score, Lutaml::Model::Type::Float, default: 0.0
+  end
+
+  class Shape < Lutaml::Model::Serializable
+    attribute :area, :float
+  end
+
+  class Circle < Shape
+    attribute :radius, Lutaml::Model::Type::Float
+  end
+
+  class Square < Shape
+    attribute :side, Lutaml::Model::Type::Float
+  end
+
+  class PolymorphicModel < Lutaml::Model::Serializable
+    attribute :shape, Shape, polymorphic: [Circle, Square]
+  end
 end
 
 RSpec.describe Lutaml::Model::Schema::YamlSchema do
   describe ".generate" do
-    it "generates a YAML schema for nested Serialize objects" do
-      schema = described_class.generate(SchemaGeneration::Vase)
-
-      expected_schema = <<~YAML
-        ---
-        type: map
-        mapping:
-          height:
-            type: float
-          diameter:
-            type: float
-          glaze:
-            type: map
-            mapping:
-              color:
-                type: str
-              finish:
-                type: str
-          materials:
-            type: seq
-            sequence:
-            - type: str
-      YAML
-
-      expect(schema).to eq(expected_schema)
+    context "with basic model" do
+      let(:schema) do
+        described_class.generate(
+          YamlSchemaSpec::Vase,
+          id: "http://stsci.edu/schemas/yaml-schema/draft-01",
+          description: "A vase schema",
+        )
+      end
+
+      let(:expected_schema) do
+        <<~YAML
+          %YAML 1.1
+          ---
+          "$schema": https://json-schema.org/draft/2020-12/schema
+          "$id": http://stsci.edu/schemas/yaml-schema/draft-01
+          description: A vase schema
+          "$ref": "#/$defs/YamlSchemaSpec_Vase"
+          "$defs":
+            YamlSchemaSpec_Vase:
+              type: object
+              additionalProperties: false
+              properties:
+                height:
+                  type:
+                  - number
+                  - 'null'
+                diameter:
+                  type:
+                  - number
+                  - 'null'
+                glaze:
+                  "$ref": "#/$defs/YamlSchemaSpec_Glaze"
+                materials:
+                  type: array
+                  items:
+                    type: string
+            YamlSchemaSpec_Glaze:
+              type: object
+              additionalProperties: false
+              properties:
+                color:
+                  type:
+                  - string
+                  - 'null'
+                finish:
+                  type:
+                  - string
+                  - 'null'
+
+        YAML
+      end
+
+      it "generates a YAML schema for nested Serialize objects" do
+        expect(schema).to eq(expected_schema)
+      end
+    end
+
+    context "with choice validation" do
+      let(:schema) do
+        described_class.generate(YamlSchemaSpec::ChoiceModel)
+      end
+
+      let(:expected_schema) do
+        <<~YAML
+          %YAML 1.1
+          ---
+          "$schema": https://json-schema.org/draft/2020-12/schema
+          "$ref": "#/$defs/YamlSchemaSpec_ChoiceModel"
+          "$defs":
+            YamlSchemaSpec_ChoiceModel:
+              type: object
+              additionalProperties: false
+              properties:
+                name:
+                  type:
+                  - string
+                  - 'null'
+                email:
+                  type:
+                  - string
+                  - 'null'
+                phone:
+                  type:
+                  - string
+                  - 'null'
+              oneOf:
+              - type: object
+                properties:
+                  email:
+                    type:
+                    - string
+                    - 'null'
+                  phone:
+                    type:
+                    - string
+                    - 'null'
+        YAML
+      end
+
+      it "generates a YAML schema with choice constraints" do
+        expect(schema.strip).to eq(expected_schema.strip)
+      end
+    end
+
+    context "with validation constraints" do
+      let(:schema) do
+        described_class.generate(YamlSchemaSpec::ValidationModel)
+      end
+
+      let(:expected_schema) do
+        <<~YAML
+          %YAML 1.1
+          ---
+          "$schema": https://json-schema.org/draft/2020-12/schema
+          "$ref": "#/$defs/YamlSchemaSpec_ValidationModel"
+          "$defs":
+            YamlSchemaSpec_ValidationModel:
+              type: object
+              additionalProperties: false
+              properties:
+                name:
+                  type:
+                  - string
+                  - 'null'
+                  enum:
+                  - Alice
+                  - Bob
+                  - Charlie
+                email:
+                  type:
+                  - string
+                  - 'null'
+                  pattern: ".*?\\\\S+@.+\\\\.\\\\S+"
+                age:
+                  type: array
+                  items:
+                    type: integer
+                  minItems: 1
+                  maxItems: 3
+                score:
+                  type:
+                  - number
+                  - 'null'
+                  default: 0.0
+        YAML
+      end
+
+      it "generates a YAML schema with validation constraints" do
+        expect(schema.strip).to eq(expected_schema.strip)
+      end
+    end
+
+    context "with polymorphic types" do
+      let(:schema) do
+        described_class.generate(YamlSchemaSpec::PolymorphicModel)
+      end
+
+      let(:expected_schema) do
+        <<~YAML
+          %YAML 1.1
+          ---
+          "$schema": https://json-schema.org/draft/2020-12/schema
+          "$ref": "#/$defs/YamlSchemaSpec_PolymorphicModel"
+          "$defs":
+            YamlSchemaSpec_PolymorphicModel:
+              type: object
+              additionalProperties: false
+              properties:
+                shape:
+                  type:
+                  - object
+                  - 'null'
+                  oneOf:
+                  - "$ref": "#/$defs/YamlSchemaSpec_Circle"
+                  - "$ref": "#/$defs/YamlSchemaSpec_Square"
+                  - "$ref": "#/$defs/YamlSchemaSpec_Shape"
+            YamlSchemaSpec_Shape:
+              type: object
+              additionalProperties: false
+              properties:
+                area:
+                  type:
+                  - number
+                  - 'null'
+            YamlSchemaSpec_Circle:
+              type: object
+              additionalProperties: false
+              properties:
+                area:
+                  type:
+                  - number
+                  - 'null'
+                radius:
+                  type:
+                  - number
+                  - 'null'
+            YamlSchemaSpec_Square:
+              type: object
+              additionalProperties: false
+              properties:
+                area:
+                  type:
+                  - number
+                  - 'null'
+                side:
+                  type:
+                  - number
+                  - 'null'
+        YAML
+      end
+
+      it "generates a YAML schema with polymorphic type constraints" do
+        expect(schema.strip).to eq(expected_schema.strip)
+      end
     end
   end
 end

data/spec/lutaml/model/sequence_spec.rb

@@ -50,6 +50,17 @@ module SequenceSpec
       map_element "ceramic", to: :ceramic
     end
   end
+
+  class CeramicRestricted < Ceramic
+    restrict :id, collection: 0..1
+    restrict :name, collection: 0..1
+    restrict :type, collection: 0..1
+    restrict :color, collection: 0..1
+    restrict :bold, collection: 0..1
+    restrict :text, collection: 0..1
+    restrict :usage, collection: 0..1
+    restrict :size, collection: 1..2
+  end
 end
 
 RSpec.describe "Sequence" do
@@ -229,4 +240,29 @@ RSpec.describe "Sequence" do
       end.to raise_error(Lutaml::Model::UnknownSequenceMappingError, "map_attribute is not allowed in sequence")
     end
   end
+
+  describe "#validate_content!" do
+    let(:sequence) { SequenceSpec::CeramicRestricted.mappings_for(:xml).element_sequence[0] }
+    let(:klass) { SequenceSpec::CeramicRestricted }
+
+    it "does not raise for correct order" do
+      expect { sequence.validate_content!(["tag", "id", "name", "type", "color", "bold", "text", "usage", "size"], klass) }
+        .not_to raise_error
+    end
+
+    it "raises for incorrect order" do
+      expect { sequence.validate_content!(["tag", "name", "id", "type", "color", "bold", "text", "usage", "size"], klass) }
+        .to raise_error(Lutaml::Model::IncorrectSequenceError)
+    end
+
+    it "raises for unknown tag" do
+      expect { sequence.validate_content!(["tag", "id", "name", "foo", "type", "color", "bold", "text", "usage", "size"], klass) }
+        .to raise_error(Lutaml::Model::IncorrectSequenceError)
+    end
+
+    it "raises error for missing required tag" do
+      expect { sequence.validate_content!(["tag", "id", "name", "type", "color", "bold", "text", "usage"], klass) }
+        .to raise_error(Lutaml::Model::ElementCountOutOfRangeError)
+    end
+  end
 end

data/spec/lutaml/model/serializable_spec.rb

@@ -96,6 +96,48 @@ module SerializeableSpec
                                         }
     end
   end
+
+  ### Single option serialization
+
+  class SingleOptionModel < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :age, :integer
+    attribute :phone, :string
+    attribute :address, :string
+
+    json do
+      map "name", to: :name
+      map "age", to: :age
+      map "phone", to: :phone, with: { to: :phone_to_json }
+      map "address", to: :address, with: { from: :address_from_json }
+    end
+
+    xml do
+      root "person"
+      map_element "name", to: :name
+      map_element "age", to: :age
+      map_element "phone", to: :phone, with: { to: :phone_to_xml }
+      map_element "address", to: :address, with: { from: :address_from_xml }
+    end
+
+    def phone_to_json(model, doc)
+      doc["phone"] = "+1-#{model.phone}"
+    end
+
+    def address_from_json(model, value)
+      model.address = value.sub(/^Address: /, "")
+    end
+
+    def phone_to_xml(model, parent, doc)
+      el = doc.create_element("phone")
+      doc.add_text(el, "+1-#{model.phone}")
+      doc.add_element(parent, el)
+    end
+
+    def address_from_xml(model, value)
+      model.address = value.text.sub(/^Address: /, "")
+    end
+  end
 end
 
 RSpec.describe Lutaml::Model::Serializable do
@@ -151,45 +193,34 @@ RSpec.describe Lutaml::Model::Serializable do
     end
   end
 
-  describe ".hash_representation" do
-    context "when model is separate" do
-      let(:instance) do
-        SerializeableSpec::TestModel.new(name: "John", age: 18)
-      end
+  describe ".restrict" do
+    before do
+      stub_const("RestrictTestClass", Class.new(described_class))
+      RestrictTestClass.attribute(:foo, :string, collection: 1..3, values: [1, 2, 3])
+    end
 
-      let(:expected_hash) do
-        {
-          "name" => "John",
-          "age" => "18",
-        }
-      end
+    it "merges new options into the attribute's options" do
+      expect { RestrictTestClass.restrict(:foo, collection: 2..4) }
+        .to change { RestrictTestClass.attributes[:foo].options[:collection] }
+        .from(1..3).to(2..4)
 
-      it "return hash representation" do
-        generate_hash = SerializeableSpec::TestModelMapper.hash_representation(
-          instance, :yaml
-        )
-        expect(generate_hash).to eq(expected_hash)
-      end
+      expect(RestrictTestClass.attributes[:foo].options[:values]).to eq([1, 2, 3])
     end
 
-    context "when model is self" do
-      let(:instance) do
-        SerializeableSpec::TestMapper.new(name: "John", age: 18)
-      end
+    it "does not remove existing options not specified in restrict" do
+      RestrictTestClass.restrict(:foo, collection: 5..6, values: [4, 5, 6])
+      expect(RestrictTestClass.attributes[:foo].options[:collection]).to eq(5..6)
+      expect(RestrictTestClass.attributes[:foo].options[:values]).to eq([4, 5, 6])
+    end
 
-      let(:expected_hash) do
-        {
-          "na" => "John",
-          "ag" => "18",
-        }
-      end
+    it "raises an error for invalid options" do
+      expect { RestrictTestClass.restrict(:foo, new_option: :bar) }
+        .to raise_error(Lutaml::Model::InvalidAttributeOptionsError, "Invalid options given for `foo` [:new_option]")
+    end
 
-      it "return hash representation" do
-        generate_hash = SerializeableSpec::TestMapper.hash_representation(
-          instance, :yaml
-        )
-        expect(generate_hash).to eq(expected_hash)
-      end
+    it "raises an error if the attribute does not exist" do
+      expect { RestrictTestClass.restrict(:bar, collection: 1..2) }
+        .to raise_error(NoMethodError)
     end
   end
 
@@ -221,67 +252,68 @@ RSpec.describe Lutaml::Model::Serializable do
     end
   end
 
-  describe ".translate_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(:attr) { SerializeableSpec::TranslateMappings.attributes[:translate] }
-
-    let(:expected_value) do
-      [
-        SerializeableSpec::TranslateHelper.new({
-                                                 "id" => "foo",
-                                                 "name" => "one",
-                                                 "path" => "link one",
-                                               }),
-        SerializeableSpec::TranslateHelper.new({
-                                                 "id" => "abc",
-                                                 "name" => "two",
-                                                 "path" => "link two",
-                                               }),
-        SerializeableSpec::TranslateHelper.new({
-                                                 "id" => "hello",
-                                                 "name" => "three",
-                                                 "path" => "link three",
-                                               }),
-      ]
-    end
-
-    it "generates hash based on child_mappings" do
-      actual_value = described_class.translate_mappings(hash, child_mappings, attr, :yaml)
-
-      expect(actual_value.map { |obj| [obj.id, obj.name, obj.path] })
-        .to eq(expected_value.map { |obj| [obj.id, obj.name, obj.path] })
-    end
-  end
+  # TODO: Move to key_value_transform specs
+  # describe ".translate_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(:attr) { SerializeableSpec::TranslateMappings.attributes[:translate] }
+
+  #   let(:expected_value) do
+  #     [
+  #       SerializeableSpec::TranslateHelper.new({
+  #                                                "id" => "foo",
+  #                                                "name" => "one",
+  #                                                "path" => "link one",
+  #                                              }),
+  #       SerializeableSpec::TranslateHelper.new({
+  #                                                "id" => "abc",
+  #                                                "name" => "two",
+  #                                                "path" => "link two",
+  #                                              }),
+  #       SerializeableSpec::TranslateHelper.new({
+  #                                                "id" => "hello",
+  #                                                "name" => "three",
+  #                                                "path" => "link three",
+  #                                              }),
+  #     ]
+  #   end
+
+  #   it "generates hash based on child_mappings" do
+  #     actual_value = described_class.translate_mappings(hash, child_mappings, attr, :yaml)
+
+  #     expect(actual_value.map { |obj| [obj.id, obj.name, obj.path] })
+  #       .to eq(expected_value.map { |obj| [obj.id, obj.name, obj.path] })
+  #   end
+  # end
 
   describe "#key_value" do
     let(:model) { SerializeableSpec::KeyValueMapper }
@@ -386,4 +418,79 @@ RSpec.describe Lutaml::Model::Serializable do
       end
     end
   end
+
+  describe "Single option serialization" do
+    let(:attributes) do
+      {
+        name: "John Doe",
+        age: 30,
+        phone: "123-456-7890",
+        address: "123 Main St",
+      }
+    end
+
+    let(:model) { SerializeableSpec::SingleOptionModel.new(attributes) }
+
+    describe "JSON serialization" do
+      let(:expected_json) do
+        {
+          name: "John Doe",
+          age: 30,
+          phone: "+1-123-456-7890",
+          address: "123 Main St",
+        }.to_json
+      end
+
+      let(:parsed) do
+        SerializeableSpec::SingleOptionModel.from_json(
+          {
+            name: "John Doe",
+            age: 30,
+            phone: "123-456-7890",
+            address: "Address: 123 Main St",
+          }.to_json,
+        )
+      end
+
+      it "serializes to JSON with custom name transformation" do
+        expect(model.to_json).to eq(expected_json)
+      end
+
+      it "deserializes from JSON with custom name transformation" do
+        expect(parsed).to eq(model)
+      end
+    end
+
+    describe "XML serialization" do
+      let(:expected_xml) do
+        <<~XML
+          <person>
+            <name>John Doe</name>
+            <age>30</age>
+            <phone>+1-123-456-7890</phone>
+            <address>123 Main St</address>
+          </person>
+        XML
+      end
+
+      let(:parsed) do
+        SerializeableSpec::SingleOptionModel.from_xml <<~XML
+          <person>
+            <name>John Doe</name>
+            <age>30</age>
+            <phone>123-456-7890</phone>
+            <address>Address: 123 Main St</address>
+          </person>
+        XML
+      end
+
+      it "serializes to XML with custom name transformation" do
+        expect(model.to_xml).to be_equivalent_to(expected_xml)
+      end
+
+      it "deserializes from XML with custom name transformation" do
+        expect(parsed).to eq(model)
+      end
+    end
+  end
 end