lluminary 0.1.4 → 0.2.1

data/spec/lluminary/schema_model_spec.rb

@@ -169,4 +169,263 @@ RSpec.describe Lluminary::SchemaModel do
       )
     end
   end
+
+  describe "boolean field validation" do
+    let(:fields) do
+      { active: { type: :boolean, description: "Whether the item is active" } }
+    end
+    let(:model_class) { described_class.build(fields: fields, validations: []) }
+
+    it "accepts true values" do
+      instance = model_class.new(active: true)
+      expect(instance.valid?).to be true
+      expect(instance.errors.full_messages).to be_empty
+    end
+
+    it "accepts false values" do
+      instance = model_class.new(active: false)
+      expect(instance.valid?).to be true
+      expect(instance.errors.full_messages).to be_empty
+    end
+
+    it "accepts nil values" do
+      instance = model_class.new(active: nil)
+      expect(instance.valid?).to be true
+      expect(instance.errors.full_messages).to be_empty
+    end
+
+    it "returns errors for non-boolean values" do
+      instance = model_class.new(active: "true")
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Active must be true or false"
+      )
+
+      instance = model_class.new(active: 1)
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Active must be true or false"
+      )
+    end
+
+    it "can be required using presence validation" do
+      validations = [[[:active], { presence: true }]]
+      model_class_with_presence =
+        described_class.build(fields: fields, validations: validations)
+      instance = model_class_with_presence.new(active: nil)
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Active can't be blank"
+      )
+    end
+  end
+
+  describe "hash field with array validation" do
+    let(:fields) do
+      {
+        config: {
+          type: :hash,
+          description: "Configuration",
+          fields: {
+            name: {
+              type: :string,
+              description: nil
+            },
+            tags: {
+              type: :array,
+              description: nil,
+              element_type: {
+                type: :string,
+                description: nil
+              }
+            }
+          }
+        }
+      }
+    end
+    let(:model_class) { described_class.build(fields: fields, validations: []) }
+
+    it "validates arrays inside hashes" do
+      instance =
+        model_class.new(
+          config: {
+            name: "test",
+            tags: ["valid", 123, "also valid"]
+          }
+        )
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Config[tags][1] must be a String"
+      )
+    end
+  end
+
+  describe "nested hash validation" do
+    let(:fields) do
+      {
+        config: {
+          type: :hash,
+          description: nil,
+          fields: {
+            name: {
+              type: :string,
+              description: nil
+            },
+            database: {
+              type: :hash,
+              description: nil,
+              fields: {
+                host: {
+                  type: :string,
+                  description: nil
+                },
+                port: {
+                  type: :integer,
+                  description: nil
+                },
+                credentials: {
+                  type: :hash,
+                  description: nil,
+                  fields: {
+                    username: {
+                      type: :string,
+                      description: nil
+                    },
+                    password: {
+                      type: :string,
+                      description: nil
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    end
+    let(:model_class) { described_class.build(fields: fields, validations: []) }
+
+    it "validates nested hashes" do
+      instance =
+        model_class.new(
+          config: {
+            name: "test",
+            database: {
+              host: 123, # should be string
+              port: "80", # should be integer
+              credentials: {
+                username: 456, # should be string
+                password: 789 # should be string
+              }
+            }
+          }
+        )
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Config[database][host] must be a String",
+        "Config[database][port] must be an Integer",
+        "Config[database][credentials][username] must be a String",
+        "Config[database][credentials][password] must be a String"
+      )
+    end
+  end
+
+  describe "hash type enforcement" do
+    let(:fields) do
+      {
+        config: {
+          type: :hash,
+          description: nil,
+          fields: {
+            host: {
+              type: :string,
+              description: nil
+            }
+          }
+        }
+      }
+    end
+    let(:model_class) { described_class.build(fields: fields, validations: []) }
+
+    it "validates that value is a hash" do
+      instance = model_class.new(config: "not a hash")
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Config must be a Hash"
+      )
+    end
+  end
+
+  describe "array of hashes validation" do
+    let(:fields) do
+      {
+        users: {
+          type: :array,
+          description: nil,
+          element_type: {
+            type: :hash,
+            description: nil,
+            fields: {
+              name: {
+                type: :string,
+                description: nil
+              },
+              age: {
+                type: :integer,
+                description: nil
+              }
+            }
+          }
+        }
+      }
+    end
+    let(:model_class) { described_class.build(fields: fields, validations: []) }
+
+    it "validates hashes inside arrays" do
+      instance =
+        model_class.new(
+          users: [
+            { name: "Alice", age: 30 },
+            { name: 123, age: "invalid" }, # name should be string, age should be integer
+            { name: "Bob", age: 25 }
+          ]
+        )
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Users[1][name] must be a String",
+        "Users[1][age] must be an Integer"
+      )
+    end
+  end
+
+  describe "float field validation" do
+    let(:fields) { { score: { type: :float, description: "The score" } } }
+    let(:model_class) { described_class.build(fields: fields, validations: []) }
+
+    it "accepts float values" do
+      instance = model_class.new(score: 3.14)
+      expect(instance.valid?).to be true
+      expect(instance.errors.full_messages).to be_empty
+    end
+
+    it "accepts nil values" do
+      instance = model_class.new(score: nil)
+      expect(instance.valid?).to be true
+      expect(instance.errors.full_messages).to be_empty
+    end
+
+    it "returns errors for non-float values" do
+      instance = model_class.new(score: "not a float")
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Score must be a float"
+      )
+
+      instance = model_class.new(score: 42)
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Score must be a float"
+      )
+    end
+  end
 end

data/spec/lluminary/schema_spec.rb

@@ -10,6 +10,58 @@ RSpec.describe Lluminary::Schema do
     end
   end
 
+  describe "#validate" do
+    it "registers a custom validation method" do
+      schema.validate(:validate_something)
+      expect(schema.custom_validations).to eq(
+        [{ method: :validate_something, description: nil }]
+      )
+    end
+
+    it "can register multiple validation methods" do
+      schema.validate(:validate_something)
+      schema.validate(:validate_something_else)
+      expect(schema.custom_validations).to eq(
+        [
+          { method: :validate_something, description: nil },
+          { method: :validate_something_else, description: nil }
+        ]
+      )
+    end
+
+    it "registers a custom validation method with a description" do
+      schema.validate(
+        :validate_score_range,
+        description: "Score must be between 0 and 100"
+      )
+      expect(schema.custom_validations).to eq(
+        [
+          {
+            method: :validate_score_range,
+            description: "Score must be between 0 and 100"
+          }
+        ]
+      )
+    end
+
+    it "registers multiple custom validations with and without descriptions" do
+      schema.validate(
+        :validate_score_range,
+        description: "Score must be between 0 and 100"
+      )
+      schema.validate(:validate_score_parity)
+      expect(schema.custom_validations).to eq(
+        [
+          {
+            method: :validate_score_range,
+            description: "Score must be between 0 and 100"
+          },
+          { method: :validate_score_parity, description: nil }
+        ]
+      )
+    end
+  end
+
   describe "#string" do
     it "adds a string field to the schema" do
       schema.string(:name)
@@ -213,10 +265,154 @@ RSpec.describe Lluminary::Schema do
       )
     end
 
-    it "validates array elements" do
-      schema.array(:numbers) { integer }
-      errors = schema.validate(numbers: [1, "2", 3])
-      expect(errors).to contain_exactly("Numbers[1] must be an Integer")
+    it "supports hashes inside arrays" do
+      schema.array(:users) do
+        hash do
+          string :name
+          integer :age
+        end
+      end
+
+      expect(schema.fields[:users]).to eq(
+        {
+          type: :array,
+          description: nil,
+          element_type: {
+            type: :hash,
+            description: nil,
+            fields: {
+              name: {
+                type: :string,
+                description: nil
+              },
+              age: {
+                type: :integer,
+                description: nil
+              }
+            }
+          }
+        }
+      )
+    end
+  end
+
+  describe "#hash" do
+    it "requires a block for hash fields" do
+      expect { schema.hash(:config) }.to raise_error(
+        ArgumentError,
+        "Hash fields must be defined with a block"
+      )
+    end
+
+    it "adds a hash field with nested fields to the schema" do
+      schema.hash(:config, description: "Configuration") do
+        string :host, description: "The server hostname"
+        integer :port
+      end
+
+      expect(schema.fields).to eq(
+        {
+          config: {
+            type: :hash,
+            description: "Configuration",
+            fields: {
+              host: {
+                type: :string,
+                description: "The server hostname"
+              },
+              port: {
+                type: :integer,
+                description: nil
+              }
+            }
+          }
+        }
+      )
+    end
+
+    it "supports nested hashes" do
+      schema.hash(:config) do
+        string :name
+        hash :database do
+          string :host
+          integer :port
+          hash :credentials do
+            string :username
+            string :password
+          end
+        end
+      end
+
+      expect(schema.fields[:config]).to eq(
+        {
+          type: :hash,
+          description: nil,
+          fields: {
+            name: {
+              type: :string,
+              description: nil
+            },
+            database: {
+              type: :hash,
+              description: nil,
+              fields: {
+                host: {
+                  type: :string,
+                  description: nil
+                },
+                port: {
+                  type: :integer,
+                  description: nil
+                },
+                credentials: {
+                  type: :hash,
+                  description: nil,
+                  fields: {
+                    username: {
+                      type: :string,
+                      description: nil
+                    },
+                    password: {
+                      type: :string,
+                      description: nil
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      )
+    end
+
+    it "supports arrays inside hashes" do
+      schema.hash(:config) do
+        string :name
+        array :tags do
+          string
+        end
+      end
+
+      expect(schema.fields[:config]).to eq(
+        {
+          type: :hash,
+          description: nil,
+          fields: {
+            name: {
+              type: :string,
+              description: nil
+            },
+            tags: {
+              type: :array,
+              description: nil,
+              element_type: {
+                type: :string,
+                description: nil
+              }
+            }
+          }
+        }
+      )
     end
   end
 
@@ -254,136 +450,6 @@ RSpec.describe Lluminary::Schema do
       second_call = schema.fields
       expect(first_call).to be(second_call)
     end
-
-    context "with datetime fields" do
-      let(:schema) { described_class.new.tap { |s| s.datetime(:start_time) } }
-
-      it "accepts DateTime values" do
-        errors = schema.validate(start_time: DateTime.now)
-        expect(errors).to be_empty
-      end
-
-      it "accepts nil values" do
-        errors = schema.validate(start_time: nil)
-        expect(errors).to be_empty
-      end
-
-      it "returns errors for non-DateTime values" do
-        errors = schema.validate(start_time: "2024-01-01")
-        expect(errors).to contain_exactly("Start time must be a DateTime")
-      end
-
-      it "can be required using presence validation" do
-        schema.validates :start_time, presence: true
-        errors = schema.validate(start_time: nil)
-        expect(errors).to contain_exactly("Start time can't be blank")
-      end
-    end
-  end
-
-  describe "#validate" do
-    let(:schema) do
-      described_class.new.tap do |s|
-        s.string(:name)
-        s.integer(:age)
-      end
-    end
-
-    it "returns no errors when all values match their field types" do
-      errors = schema.validate(name: "John", age: 30)
-      expect(errors).to be_empty
-    end
-
-    it "returns errors for type mismatches" do
-      errors = schema.validate(name: 123, age: "30")
-      expect(errors).to contain_exactly(
-        "Name must be a String",
-        "Age must be an Integer"
-      )
-    end
-
-    context "with boolean fields" do
-      let(:schema) { described_class.new.tap { |s| s.boolean(:active) } }
-
-      it "accepts true values" do
-        errors = schema.validate(active: true)
-        expect(errors).to be_empty
-      end
-
-      it "accepts false values" do
-        errors = schema.validate(active: false)
-        expect(errors).to be_empty
-      end
-
-      it "accepts nil values" do
-        errors = schema.validate(active: nil)
-        expect(errors).to be_empty
-      end
-
-      it "returns errors for non-boolean values" do
-        errors = schema.validate(active: "true")
-        expect(errors).to contain_exactly("Active must be true or false")
-
-        errors = schema.validate(active: 1)
-        expect(errors).to contain_exactly("Active must be true or false")
-      end
-
-      it "can be required using presence validation" do
-        schema.validates :active, presence: true
-        errors = schema.validate(active: nil)
-        expect(errors).to contain_exactly("Active can't be blank")
-      end
-    end
-
-    context "with string fields" do
-      let(:schema) { described_class.new.tap { |s| s.string(:name) } }
-
-      it "accepts string values" do
-        errors = schema.validate(name: "John")
-        expect(errors).to be_empty
-      end
-
-      it "accepts nil values" do
-        errors = schema.validate(name: nil)
-        expect(errors).to be_empty
-      end
-
-      it "returns errors for non-string values" do
-        errors = schema.validate(name: 123)
-        expect(errors).to contain_exactly("Name must be a String")
-      end
-
-      it "can be required using presence validation" do
-        schema.validates :name, presence: true
-        errors = schema.validate(name: nil)
-        expect(errors).to contain_exactly("Name can't be blank")
-      end
-    end
-
-    context "with integer fields" do
-      let(:schema) { described_class.new.tap { |s| s.integer(:age) } }
-
-      it "accepts integer values" do
-        errors = schema.validate(age: 30)
-        expect(errors).to be_empty
-      end
-
-      it "accepts nil values" do
-        errors = schema.validate(age: nil)
-        expect(errors).to be_empty
-      end
-
-      it "returns errors for non-integer values" do
-        errors = schema.validate(age: "30")
-        expect(errors).to contain_exactly("Age must be an Integer")
-      end
-
-      it "can be required using presence validation" do
-        schema.validates :age, presence: true
-        errors = schema.validate(age: nil)
-        expect(errors).to contain_exactly("Age can't be blank")
-      end
-    end
   end
 
   describe "ActiveModel validations" do
@@ -433,4 +499,32 @@ RSpec.describe Lluminary::Schema do
       expect(instance.valid?).to be true
     end
   end
+
+  describe "custom method validations" do
+    it "passes custom validations to schema model" do
+      schema = described_class.new
+      schema.integer(:score)
+      schema.validate(:validate_score_range)
+
+      model_class = schema.schema_model
+      method_names =
+        model_class.custom_validation_methods.map { |v| v[:method] }
+      expect(method_names).to contain_exactly(:validate_score_range)
+    end
+
+    it "accepts multiple custom validations" do
+      schema = described_class.new
+      schema.integer(:score)
+      schema.validate(:validate_score_range)
+      schema.validate(:validate_score_parity)
+
+      model_class = schema.schema_model
+      method_names =
+        model_class.custom_validation_methods.map { |v| v[:method] }
+      expect(method_names).to contain_exactly(
+        :validate_score_range,
+        :validate_score_parity
+      )
+    end
+  end
 end