lluminary 0.1.1 → 0.1.3

data/spec/lluminary/task_spec.rb

@@ -1,4 +1,5 @@
-require 'spec_helper'
+# frozen_string_literal: true
+require "spec_helper"
 
 RSpec.describe Lluminary::Task do
   let(:task_class) do
@@ -11,570 +12,79 @@ RSpec.describe Lluminary::Task do
         string :summary, description: "A brief summary of the message"
       end
 
-      private
-
       def task_prompt
         "Say: #{message}"
       end
     end
   end
 
-  let(:task_with_test) do
-    Class.new(described_class) do
-      use_provider :test
-    end
-  end
+  let(:task_with_test) { Class.new(described_class) { use_provider :test } }
 
-  describe '.call' do
-    it 'returns a result with a raw response from the provider' do
+  describe ".call" do
+    it "returns a result with a raw response from the provider" do
       result = task_class.call(message: "hello")
-      expect(result.output.raw_response).to eq('{"summary": "Test string value"}')
-    end
-
-    it 'string input allows providing a string input' do
-      result = task_class.call(message: "hello")
-      expect(result.output.raw_response).to eq('{"summary": "Test string value"}')
+      expect(result.output.raw_response).to eq(
+        '{"summary": "Test string value"}'
+      )
     end
 
-    it 'string output returns the output in the result' do
+    it "string output returns the output in the result" do
       result = task_class.call(message: "hello")
       expect(result.output.summary).to eq("Test string value")
     end
-
-    it 'includes schema descriptions in the prompt' do
-      result = task_class.call(message: "hello")
-      expected_schema = <<~SCHEMA
-        You must respond with ONLY a valid JSON object. Do not include any other text, explanations, or formatting.
-        The JSON object must contain the following fields:
-
-        summary (string): A brief summary of the message
-        Example: "your summary here"
-
-        Your response must be ONLY this JSON object:
-        {
-          "summary": "your summary here"
-        }
-      SCHEMA
-      expect(result.prompt).to include(expected_schema.chomp)
-    end
   end
 
-  describe '.call without descriptions' do
-    let(:task_without_descriptions) do
-      Class.new(described_class) do
-        input_schema do
-          string :message
-        end
-
-        output_schema do
-          string :summary
-        end
-
-        private
-
-        def task_prompt
-          "Say: #{message}"
-        end
-      end
-    end
-
-    it 'includes basic schema in the prompt' do
-      result = task_without_descriptions.call(message: "hello")
-      expected_schema = <<~SCHEMA
-        You must respond with ONLY a valid JSON object. Do not include any other text, explanations, or formatting.
-        The JSON object must contain the following fields:
-
-        summary (string)
-        Example: "your summary here"
-
-        Your response must be ONLY this JSON object:
-        {
-          "summary": "your summary here"
-        }
-      SCHEMA
-      expect(result.prompt).to include(expected_schema.chomp)
-    end
-  end
-
-  describe '.provider' do
-    it 'defaults to Test provider' do
+  describe ".provider" do
+    it "defaults to Test provider" do
       expect(task_class.provider).to be_a(Lluminary::Providers::Test)
     end
 
-    it 'allows setting a custom provider' do
-      custom_provider = double('CustomProvider')
+    it "allows setting a custom provider" do
+      custom_provider = double("CustomProvider")
       task_class.provider = custom_provider
       expect(task_class.provider).to eq(custom_provider)
     end
   end
 
-  describe '.use_provider' do
-    it 'with :test provider sets the test provider' do
+  describe ".use_provider" do
+    it "with :test provider sets the test provider" do
       expect(task_with_test.provider).to be_a(Lluminary::Providers::Test)
     end
 
-    it 'with :openai instantiates OpenAI provider with config' do
-      task_class.use_provider(:openai, api_key: 'test')
+    it "with :openai instantiates OpenAI provider with config" do
+      task_class.use_provider(:openai, api_key: "test")
       expect(task_class.provider).to be_a(Lluminary::Providers::OpenAI)
-      expect(task_class.provider.config).to eq(api_key: 'test', model: 'gpt-4o')
-    end
-
-    it 'raises ArgumentError for unknown provider' do
-      expect {
-        task_class.use_provider(:unknown)
-      }.to raise_error(ArgumentError, "Unknown provider: unknown")
-    end
-  end
-
-  describe '#json_schema_example' do
-    it 'generates a schema example with descriptions' do
-      task = task_class.new(message: "test")
-      expected_output = <<~SCHEMA
-        You must respond with ONLY a valid JSON object. Do not include any other text, explanations, or formatting.
-        The JSON object must contain the following fields:
-
-        summary (string): A brief summary of the message
-        Example: "your summary here"
-
-        Your response must be ONLY this JSON object:
-        {
-          "summary": "your summary here"
-        }
-      SCHEMA
-      expect(task.send(:json_schema_example)).to eq(expected_output.chomp)
-    end
-
-    it 'generates a schema example with datetime field' do
-      task_with_datetime = Class.new(described_class) do
-        input_schema do
-          string :message
-        end
-
-        output_schema do
-          datetime :start_time, description: "When the event starts"
-        end
-
-        private
-
-        def task_prompt
-          "Say: #{message}"
-        end
-      end
-
-      task = task_with_datetime.new(message: "test")
-      expected_output = <<~SCHEMA
-        You must respond with ONLY a valid JSON object. Do not include any other text, explanations, or formatting.
-        The JSON object must contain the following fields:
-
-        start_time (datetime in ISO8601 format): When the event starts
-        Example: "2024-01-01T12:00:00+00:00"
-
-        Your response must be ONLY this JSON object:
-        {
-          "start_time": "2024-01-01T12:00:00+00:00"
-        }
-      SCHEMA
-      expect(task.send(:json_schema_example)).to eq(expected_output.chomp)
-    end
-
-    it 'generates a schema example with boolean field' do
-      task_with_boolean = Class.new(described_class) do
-        input_schema do
-          string :message
-        end
-
-        output_schema do
-          boolean :is_valid, description: "Whether the input is valid"
-        end
-
-        private
-
-        def task_prompt
-          "Say: #{message}"
-        end
-      end
-
-      task = task_with_boolean.new(message: "test")
-      expected_output = <<~SCHEMA
-        You must respond with ONLY a valid JSON object. Do not include any other text, explanations, or formatting.
-        The JSON object must contain the following fields:
-
-        is_valid (boolean): Whether the input is valid
-        Example: true
-
-        Your response must be ONLY this JSON object:
-        {
-          "is_valid": true
-        }
-      SCHEMA
-      expect(task.send(:json_schema_example)).to eq(expected_output.chomp)
-    end
-
-    it 'generates a schema example with float field' do
-      task_with_float = Class.new(described_class) do
-        input_schema do
-          string :message
-        end
-
-        output_schema do
-          float :score, description: "The confidence score"
-        end
-
-        private
-
-        def task_prompt
-          "Say: #{message}"
-        end
-      end
-
-      task = task_with_float.new(message: "test")
-      expected_output = <<~SCHEMA
-        You must respond with ONLY a valid JSON object. Do not include any other text, explanations, or formatting.
-        The JSON object must contain the following fields:
-
-        score (float): The confidence score
-        Example: 0.0
-
-        Your response must be ONLY this JSON object:
-        {
-          "score": 0.0
-        }
-      SCHEMA
-      expect(task.send(:json_schema_example)).to eq(expected_output.chomp)
+      expect(task_class.provider.config).to include(
+        api_key: "test",
+        model: Lluminary::Models::OpenAi::Gpt35Turbo
+      )
     end
 
-    it 'generates a schema example without descriptions' do
-      task_without_descriptions = Class.new(described_class) do
-        input_schema do
-          string :message
-        end
-
-        output_schema do
-          string :summary
-        end
-
-        private
-
-        def task_prompt
-          "Say: #{message}"
-        end
-      end
-
-      task = task_without_descriptions.new(message: "test")
-      expected_output = <<~SCHEMA
-        You must respond with ONLY a valid JSON object. Do not include any other text, explanations, or formatting.
-        The JSON object must contain the following fields:
-
-        summary (string)
-        Example: "your summary here"
-
-        Your response must be ONLY this JSON object:
-        {
-          "summary": "your summary here"
-        }
-      SCHEMA
-      expect(task.send(:json_schema_example)).to eq(expected_output.chomp)
+    it "with :bedrock instantiates Bedrock provider with config" do
+      task_class.use_provider(
+        :bedrock,
+        access_key_id: "test",
+        secret_access_key: "test",
+        region: "us-east-1"
+      )
+      expect(task_class.provider).to be_a(Lluminary::Providers::Bedrock)
+      expect(task_class.provider.config).to include(
+        access_key_id: "test",
+        secret_access_key: "test",
+        region: "us-east-1",
+        model: Lluminary::Models::Bedrock::AnthropicClaudeInstantV1
+      )
     end
 
-    context 'validation descriptions' do
-      context 'presence validation' do
-        it 'includes presence validation description' do
-          task_class = Class.new(described_class) do
-            output_schema do
-              string :name, description: "The person's name"
-              validates :name, presence: true
-            end
-
-            private
-            def task_prompt; "Test prompt"; end
-          end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "name (string): The person's name\nValidation: must be present\nExample: \"your name here\""
-          )
-        end
-      end
-
-      context 'length validation' do
-        it 'includes minimum length validation description' do
-          task_class = Class.new(described_class) do
-            output_schema do
-              string :name, description: "The person's name"
-              validates :name, length: { minimum: 2 }
-            end
-
-            private
-            def task_prompt; "Test prompt"; end
-          end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "name (string): The person's name\nValidation: must be at least 2 characters\nExample: \"your name here\""
-          )
-        end
-
-        it 'includes maximum length validation description' do
-          task_class = Class.new(described_class) do
-            output_schema do
-              string :name, description: "The person's name"
-              validates :name, length: { maximum: 20 }
-            end
-
-            private
-            def task_prompt; "Test prompt"; end
-          end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "name (string): The person's name\nValidation: must be at most 20 characters\nExample: \"your name here\""
-          )
-        end
-
-        it 'includes range length validation description' do
-          task_class = Class.new(described_class) do
-            output_schema do
-              string :password, description: "The password"
-              validates :password, length: { in: 8..20 }
-            end
-
-            private
-            def task_prompt; "Test prompt"; end
-          end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "password (string): The password\nValidation: must be between 8 and 20 characters\nExample: \"your password here\""
-          )
-        end
-
-        it 'includes multiple length validations in description' do
-          task_class = Class.new(described_class) do
-            output_schema do
-              string :username, description: "The username"
-              validates :username, length: { 
-                minimum: 3,
-                maximum: 20
-              }
-            end
-
-            private
-            def task_prompt; "Test prompt"; end
-          end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "username (string): The username\nValidation: must be at least 3 characters, must be at most 20 characters\nExample: \"your username here\""
-          )
-        end
-      end
-
-      context 'numericality validation' do
-        it 'includes odd validation description' do
-          task_class = Class.new(described_class) do
-            output_schema do
-              integer :number, description: "Odd number"
-              validates :number, numericality: { odd: true }
-            end
-
-            private
-            def task_prompt; "Test prompt"; end
-          end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "number (integer): Odd number\nValidation: must be odd\nExample: 0"
-          )
-        end
-
-        it 'includes equal to validation description' do
-          task_class = Class.new(described_class) do
-            output_schema do
-              integer :level, description: "Level"
-              validates :level, numericality: { equal_to: 5 }
-            end
-
-            private
-            def task_prompt; "Test prompt"; end
-          end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "level (integer): Level\nValidation: must be equal to 5\nExample: 0"
-          )
-        end
-
-        it 'includes less than or equal to validation description' do
-          task_class = Class.new(described_class) do
-            output_schema do
-              integer :score, description: "Score"
-              validates :score, numericality: { less_than_or_equal_to: 100 }
-            end
-
-            private
-            def task_prompt; "Test prompt"; end
-          end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "score (integer): Score\nValidation: must be less than or equal to 100\nExample: 0"
-          )
-        end
-
-        it 'includes other than validation description' do
-          task_class = Class.new(described_class) do
-            output_schema do
-              integer :value, description: "Value"
-              validates :value, numericality: { other_than: 0 }
-            end
-
-            private
-            def task_prompt; "Test prompt"; end
-          end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "value (integer): Value\nValidation: must be other than 0\nExample: 0"
-          )
-        end
-
-        it 'includes in range validation description' do
-          task_class = Class.new(described_class) do
-            output_schema do
-              integer :rating, description: "Rating"
-              validates :rating, numericality: { in: 1..5 }
-            end
-
-            private
-            def task_prompt; "Test prompt"; end
-          end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "rating (integer): Rating\nValidation: must be in: 1, 2, 3, 4, 5\nExample: 0"
-          )
-        end
-
-        it 'includes multiple numericality validations in description' do
-          task_class = Class.new(described_class) do
-            output_schema do
-              integer :score, description: "Score"
-              validates :score, numericality: { 
-                greater_than: 0,
-                less_than_or_equal_to: 100
-              }
-            end
-
-            private
-            def task_prompt; "Test prompt"; end
-          end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "score (integer): Score\nValidation: must be greater than 0, must be less than or equal to 100\nExample: 0"
-          )
-        end
-
-        it 'includes multiple comparison validations in description' do
-          task_class = Class.new(described_class) do
-            output_schema do
-              integer :age, description: "Age"
-              validates :age, comparison: { 
-                greater_than: 0,
-                less_than: 120
-              }
-            end
-
-            private
-            def task_prompt; "Test prompt"; end
-          end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "age (integer): Age\nValidation: must be greater than 0, must be less than 120\nExample: 0"
-          )
-        end
-      end
-
-      context 'format validation' do
-        it 'includes format validation description' do
-          task_class = Class.new(described_class) do
-            output_schema do
-              string :email, description: "Email address"
-              validates :email, format: { with: /\A[^@\s]+@[^@\s]+\z/ }
-            end
-
-            private
-            def task_prompt; "Test prompt"; end
-          end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "email (string): Email address\nValidation: must match format: (?-mix:\\A[^@\\s]+@[^@\\s]+\\z)\nExample: \"your email here\""
-          )
-        end
-      end
-
-      context 'inclusion validation' do
-        it 'includes inclusion validation description' do
-          task_class = Class.new(described_class) do
-            output_schema do
-              string :role, description: "User role"
-              validates :role, inclusion: { in: %w[admin user guest] }
-            end
-
-            private
-            def task_prompt; "Test prompt"; end
-          end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "role (string): User role\nValidation: must be one of: admin, user, guest\nExample: \"your role here\""
-          )
-        end
-      end
-
-      context 'exclusion validation' do
-        it 'includes exclusion validation description' do
-          task_class = Class.new(described_class) do
-            output_schema do
-              string :status, description: "Status"
-              validates :status, exclusion: { in: %w[banned blocked] }
-            end
-
-            private
-            def task_prompt; "Test prompt"; end
-          end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "status (string): Status\nValidation: must not be one of: banned, blocked\nExample: \"your status here\""
-          )
-        end
-      end
-
-      context 'absence validation' do
-        it 'includes absence validation description' do
-          task_class = Class.new(described_class) do
-            output_schema do
-              string :deleted_at, description: "Deletion timestamp"
-              validates :deleted_at, absence: true
-            end
-
-            private
-            def task_prompt; "Test prompt"; end
-          end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "deleted_at (string): Deletion timestamp\nValidation: must be absent\nExample: \"your deleted_at here\""
-          )
-        end
-      end
+    it "raises ArgumentError for unknown provider" do
+      expect { task_class.use_provider(:unknown) }.to raise_error(
+        ArgumentError,
+        "Unknown provider: unknown"
+      )
     end
   end
 
-  describe '#validate_input' do
+  describe "#validate_input" do
     let(:task_with_types) do
       Class.new(described_class) do
         input_schema do
@@ -583,46 +93,58 @@ RSpec.describe Lluminary::Task do
           datetime :start_time
         end
 
-        private
-
         def task_prompt
           "Test prompt"
         end
       end
     end
 
-    it 'validates string input type' do
-      task = task_with_types.new(name: "John", age: 30, start_time: DateTime.now)
+    it "validates string input type" do
+      task =
+        task_with_types.new(name: "John", age: 30, start_time: DateTime.now)
       expect { task.send(:validate_input) }.not_to raise_error
     end
 
-    it 'raises error for invalid string input' do
+    it "raises error for invalid string input" do
       task = task_with_types.new(name: 123, age: 30, start_time: DateTime.now)
-      expect { task.send(:validate_input) }.to raise_error(Lluminary::ValidationError, "Name must be a String")
+      expect { task.send(:validate_input) }.to raise_error(
+        Lluminary::ValidationError,
+        "Name must be a String"
+      )
     end
 
-    it 'validates integer input type' do
-      task = task_with_types.new(name: "John", age: 30, start_time: DateTime.now)
+    it "validates integer input type" do
+      task =
+        task_with_types.new(name: "John", age: 30, start_time: DateTime.now)
       expect { task.send(:validate_input) }.not_to raise_error
     end
 
-    it 'raises error for invalid integer input' do
-      task = task_with_types.new(name: "John", age: "30", start_time: DateTime.now)
-      expect { task.send(:validate_input) }.to raise_error(Lluminary::ValidationError, "Age must be an Integer")
+    it "raises error for invalid integer input" do
+      task =
+        task_with_types.new(name: "John", age: "30", start_time: DateTime.now)
+      expect { task.send(:validate_input) }.to raise_error(
+        Lluminary::ValidationError,
+        "Age must be an Integer"
+      )
     end
 
-    it 'validates datetime input type' do
-      task = task_with_types.new(name: "John", age: 30, start_time: DateTime.now)
+    it "validates datetime input type" do
+      task =
+        task_with_types.new(name: "John", age: 30, start_time: DateTime.now)
       expect { task.send(:validate_input) }.not_to raise_error
     end
 
-    it 'raises error for invalid datetime input' do
-      task = task_with_types.new(name: "John", age: 30, start_time: "2024-01-01")
-      expect { task.send(:validate_input) }.to raise_error(Lluminary::ValidationError, "Start time must be a DateTime")
+    it "raises error for invalid datetime input" do
+      task =
+        task_with_types.new(name: "John", age: 30, start_time: "2024-01-01")
+      expect { task.send(:validate_input) }.to raise_error(
+        Lluminary::ValidationError,
+        "Start time must be a DateTime"
+      )
     end
   end
 
-  describe 'SchemaModel integration' do
+  describe "SchemaModel integration" do
     let(:task_with_schema) do
       Class.new(described_class) do
         input_schema do
@@ -630,7 +152,11 @@ RSpec.describe Lluminary::Task do
           integer :min_length
 
           validates :text, presence: true
-          validates :min_length, presence: true, numericality: { greater_than: 0 }
+          validates :min_length,
+                    presence: true,
+                    numericality: {
+                      greater_than: 0
+                    }
         end
 
         output_schema do
@@ -638,28 +164,26 @@ RSpec.describe Lluminary::Task do
           integer :word_count
         end
 
-        private
-
         def task_prompt
           "Test prompt"
         end
       end
     end
 
-    it 'wraps input in a SchemaModel instance' do
+    it "wraps input in a SchemaModel instance" do
       result = task_with_schema.call(text: "hello", min_length: 3)
       expect(result.input).to be_a(Lluminary::SchemaModel)
       expect(result.input.text).to eq("hello")
       expect(result.input.min_length).to eq(3)
     end
 
-    it 'validates input using SchemaModel' do
+    it "validates input using SchemaModel" do
       result = task_with_schema.call(text: "hello", min_length: 3)
       expect(result.input.valid?).to be true
       expect(result.input.errors).to be_empty
     end
 
-    it 'returns validation errors for invalid input' do
+    it "returns validation errors for invalid input" do
       result = task_with_schema.call(text: nil, min_length: nil)
       expect(result.input.valid?).to be false
       expect(result.input.errors.full_messages).to contain_exactly(
@@ -669,33 +193,37 @@ RSpec.describe Lluminary::Task do
       )
     end
 
-    it 'does not execute task when input is invalid' do
+    it "does not execute task when input is invalid" do
       result = task_with_schema.call(text: nil, min_length: nil)
       expect(result.parsed_response).to be_nil
       expect(result.output).to be_nil
     end
 
-    it 'raises ValidationError for invalid input when using call!' do
-      expect {
+    it "raises ValidationError for invalid input when using call!" do
+      expect do
         task_with_schema.call!(text: nil, min_length: nil)
-      }.to raise_error(Lluminary::ValidationError, "Text can't be blank, Min length can't be blank, Min length is not a number")
+      end.to raise_error(
+        Lluminary::ValidationError,
+        "Text can't be blank, Min length can't be blank, Min length is not a number"
+      )
     end
 
-    it 'validates that the response is valid JSON' do
+    it "validates that the response is valid JSON" do
       task = task_with_schema.new(text: "hello", min_length: 3)
-      allow(task.class.provider).to receive(:call).and_return({
-        raw: "not valid json at all",
-        parsed: nil
-      })
+      allow(task.class.provider).to receive(:call).and_return(
+        { raw: "not valid json at all", parsed: nil }
+      )
 
       result = task.call
       expect(result.input.valid?).to be true
       expect(result.output.valid?).to be false
-      expect(result.output.errors.full_messages).to include("Raw response must be valid JSON")
+      expect(result.output.errors.full_messages).to include(
+        "Raw response must be valid JSON"
+      )
     end
   end
 
-  describe 'tasks without inputs' do
+  describe "tasks without inputs" do
     let(:quote_task) do
       Class.new(described_class) do
         use_provider :test
@@ -705,21 +233,19 @@ RSpec.describe Lluminary::Task do
           string :author, description: "The person who said the quote"
         end
 
-        private
-
         def task_prompt
           "Generate an inspirational quote and its author"
         end
       end
     end
 
-    it 'can be called without any input parameters' do
+    it "can be called without any input parameters" do
       result = quote_task.call
       expect(result.output.quote).to be_a(String)
       expect(result.output.author).to be_a(String)
     end
 
-    it 'returns a valid result object' do
+    it "returns a valid result object" do
       result = quote_task.call
       expect(result).to be_a(Lluminary::Task)
       expect(result.input).to be_a(Lluminary::SchemaModel)
@@ -727,7 +253,7 @@ RSpec.describe Lluminary::Task do
     end
   end
 
-  describe 'datetime handling' do
+  describe "datetime handling" do
     let(:task_with_datetime) do
       Class.new(described_class) do
         use_provider :test
@@ -736,20 +262,22 @@ RSpec.describe Lluminary::Task do
           datetime :event_time, description: "When the event occurred"
         end
 
-        private
-
         def task_prompt
           "Test prompt"
         end
       end
     end
 
-    it 'converts ISO8601 datetime strings to DateTime objects' do
+    it "converts ISO8601 datetime strings to DateTime objects" do
       task = task_with_datetime.new
-      allow(task.class.provider).to receive(:call).and_return({
-        raw: '{"event_time": "2024-01-01T12:00:00+00:00"}',
-        parsed: { "event_time" => "2024-01-01T12:00:00+00:00" }
-      })
+      allow(task.class.provider).to receive(:call).and_return(
+        {
+          raw: '{"event_time": "2024-01-01T12:00:00+00:00"}',
+          parsed: {
+            "event_time" => "2024-01-01T12:00:00+00:00"
+          }
+        }
+      )
 
       result = task.call
       expect(result.output.valid?).to be true
@@ -762,16 +290,22 @@ RSpec.describe Lluminary::Task do
       expect(result.output.event_time.second).to eq(0)
     end
 
-    it 'handles invalid datetime strings' do
+    it "handles invalid datetime strings" do
       task = task_with_datetime.new
-      allow(task.class.provider).to receive(:call).and_return({
-        raw: '{"event_time": "not a valid datetime"}',
-        parsed: { "event_time" => "not a valid datetime" }
-      })
+      allow(task.class.provider).to receive(:call).and_return(
+        {
+          raw: '{"event_time": "not a valid datetime"}',
+          parsed: {
+            "event_time" => "not a valid datetime"
+          }
+        }
+      )
 
       result = task.call
       expect(result.output.valid?).to be false
-      expect(result.output.errors.full_messages).to include("Event time must be a DateTime")
+      expect(result.output.errors.full_messages).to include(
+        "Event time must be a DateTime"
+      )
     end
   end
-end 
+end