lluminary 0.1.2 → 0.1.4

data/spec/lluminary/providers/openai_spec.rb

@@ -11,6 +11,38 @@ RSpec.describe Lluminary::Providers::OpenAI do
     end
   end
 
+  describe "#models" do
+    let(:mock_models_response) do
+      {
+        "object" => "list",
+        "data" => [
+          {
+            "id" => "gpt-4",
+            "object" => "model",
+            "created" => 1_687_882_411,
+            "owned_by" => "openai"
+          },
+          {
+            "id" => "gpt-3.5-turbo",
+            "object" => "model",
+            "created" => 1_677_610_602,
+            "owned_by" => "openai"
+          }
+        ]
+      }
+    end
+
+    before do
+      allow_any_instance_of(OpenAI::Client).to receive(:models).and_return(
+        double("ModelsClient", list: mock_models_response)
+      )
+    end
+
+    it "returns an array of model IDs as strings" do
+      expect(provider.models).to eq(%w[gpt-4 gpt-3.5-turbo])
+    end
+  end
+
   describe "#call" do
     let(:prompt) { "Test prompt" }
     let(:task) { "Test task" }

data/spec/lluminary/providers/test_spec.rb

@@ -10,6 +10,31 @@ RSpec.describe Lluminary::Providers::Test do
   end
   let(:task) { double("Task", class: task_class) }
 
+  describe "#initialize" do
+    it "accepts configuration options" do
+      config = { api_key: "test_key", model: "test_model" }
+      provider = described_class.new(**config)
+      expect(provider.config).to eq(config)
+    end
+
+    it "merges default provider configuration with instance configuration" do
+      # Set up default provider configuration
+      Lluminary.configure do |config|
+        config.provider(:test, api_key: "global_key", model: "global_model")
+      end
+
+      # Create provider with instance-specific config
+      provider = described_class.new(model: "instance_model", temperature: 0.7)
+
+      # Should merge default and instance config, with instance taking precedence
+      expect(provider.config).to eq(
+        api_key: "global_key",
+        model: "instance_model",
+        temperature: 0.7
+      )
+    end
+  end
+
   describe "#call" do
     it "returns a hash with raw and parsed response" do
       response = provider.call(prompt, task)

data/spec/lluminary/schema_model_spec.rb

@@ -91,5 +91,82 @@ RSpec.describe Lluminary::SchemaModel do
       instance = model_class.new(name: "John", age: 30)
       expect(instance.attributes).to eq({ "name" => "John", "age" => 30 })
     end
+
+    it "validates array types" do
+      fields = {
+        items: {
+          type: :array,
+          element_type: {
+            type: :string,
+            description: nil
+          },
+          description: "A list of strings"
+        }
+      }
+      model_class = described_class.build(fields: fields, validations: [])
+
+      # Test that nil is allowed
+      instance = model_class.new(items: nil)
+      expect(instance.valid?).to be true
+
+      # Test valid array of strings
+      instance = model_class.new(items: %w[one two])
+      expect(instance.valid?).to be true
+
+      # Test invalid array (not an array)
+      instance = model_class.new(items: "not an array")
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to include("Items must be an Array")
+
+      # Test invalid array elements
+      instance = model_class.new(items: ["one", 2, "three"])
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to include(
+        "Items[1] must be a String"
+      )
+    end
+
+    it "validates nested array types" do
+      fields = {
+        matrix: {
+          type: :array,
+          element_type: {
+            type: :array,
+            element_type: {
+              type: :integer,
+              description: nil
+            },
+            description: nil
+          },
+          description: "A matrix of integers"
+        }
+      }
+      model_class = described_class.build(fields: fields, validations: [])
+
+      # Test valid nested arrays
+      instance = model_class.new(matrix: [[1, 2], [3, 4]])
+      expect(instance.valid?).to be true
+
+      # Test invalid outer array
+      instance = model_class.new(matrix: "not an array")
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to include(
+        "Matrix must be an Array"
+      )
+
+      # Test invalid inner array
+      instance = model_class.new(matrix: ["not an array"])
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to include(
+        "Matrix[0] must be an Array"
+      )
+
+      # Test invalid inner array elements
+      instance = model_class.new(matrix: [[1, "2"], [3, 4]])
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to include(
+        "Matrix[0][1] must be an Integer"
+      )
+    end
   end
 end

data/spec/lluminary/schema_spec.rb

@@ -96,6 +96,152 @@ RSpec.describe Lluminary::Schema do
     end
   end
 
+  describe "#array" do
+    it "adds an untyped array field to the schema" do
+      schema.array(:items)
+      expect(schema.fields).to eq({ items: { type: :array, description: nil } })
+    end
+
+    it "adds an untyped array field with description" do
+      schema.array(:items, description: "A list of items")
+      expect(schema.fields).to eq(
+        { items: { type: :array, description: "A list of items" } }
+      )
+    end
+
+    it "requires a name for the array field" do
+      expect { schema.array }.to raise_error(ArgumentError)
+    end
+
+    it "accepts array type without a name" do
+      schema.array(:items) { array { string } }
+      expect(schema.fields).to eq(
+        {
+          items: {
+            type: :array,
+            element_type: {
+              type: :array,
+              element_type: {
+                type: :string,
+                description: nil
+              },
+              description: nil
+            },
+            description: nil
+          }
+        }
+      )
+    end
+
+    it "accepts string type without a name" do
+      schema.array(:items) { string }
+      expect(schema.fields).to eq(
+        {
+          items: {
+            type: :array,
+            element_type: {
+              type: :string,
+              description: nil
+            },
+            description: nil
+          }
+        }
+      )
+    end
+
+    it "accepts integer type without a name" do
+      schema.array(:items) { integer }
+      expect(schema.fields).to eq(
+        {
+          items: {
+            type: :array,
+            element_type: {
+              type: :integer,
+              description: nil
+            },
+            description: nil
+          }
+        }
+      )
+    end
+
+    it "accepts boolean type without a name" do
+      schema.array(:items) { boolean }
+      expect(schema.fields).to eq(
+        {
+          items: {
+            type: :array,
+            element_type: {
+              type: :boolean,
+              description: nil
+            },
+            description: nil
+          }
+        }
+      )
+    end
+
+    it "accepts float type without a name" do
+      schema.array(:items) { float }
+      expect(schema.fields).to eq(
+        {
+          items: {
+            type: :array,
+            element_type: {
+              type: :float,
+              description: nil
+            },
+            description: nil
+          }
+        }
+      )
+    end
+
+    it "accepts datetime type without a name" do
+      schema.array(:items) { datetime }
+      expect(schema.fields).to eq(
+        {
+          items: {
+            type: :array,
+            element_type: {
+              type: :datetime,
+              description: nil
+            },
+            description: nil
+          }
+        }
+      )
+    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")
+    end
+  end
+
+  describe "primitive types" do
+    it "requires a name for string fields" do
+      expect { schema.string }.to raise_error(ArgumentError)
+    end
+
+    it "requires a name for integer fields" do
+      expect { schema.integer }.to raise_error(ArgumentError)
+    end
+
+    it "requires a name for boolean fields" do
+      expect { schema.boolean }.to raise_error(ArgumentError)
+    end
+
+    it "requires a name for float fields" do
+      expect { schema.float }.to raise_error(ArgumentError)
+    end
+
+    it "requires a name for datetime fields" do
+      expect { schema.datetime }.to raise_error(ArgumentError)
+    end
+  end
+
   describe "#fields" do
     it "returns the fields hash" do
       schema.string(:name)