Add unit tests for Params extension

Adds comprehensive unit tests for the Params extension:
- Tests for schema definition and inheritance
- Tests for validate_params method
- Tests for method wrapping with both #call and custom methods via operate_on
- Tests for validation failures and short-circuiting
- Updates spec_helper to load the Params extension

Author: aaronmallen

spec/spec_helper.rb

@@ -7,6 +7,7 @@
 
 require "dry/operation"
 require "dry/operation/extensions/active_record"
+require "dry/operation/extensions/params"
 require "dry/operation/extensions/rom"
 require "dry/operation/extensions/sequel"
 

spec/unit/extensions/params_spec.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Dry::Operation::Extensions::Params do
+  include Dry::Monads[:result]
+
+  describe ".params" do
+    it "defines a schema for the operation using a block" do
+      klass = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        params do
+          required(:name).filled(:string)
+        end
+      end
+
+      expect(klass._params_schema).to be_a(Dry::Schema::Params)
+    end
+
+    it "accepts a schema class" do
+      schema = Dry::Schema.Params do
+        required(:name).filled(:string)
+      end
+
+      klass = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        params schema
+      end
+
+      expect(klass._params_schema).to eq(schema)
+    end
+
+    it "accepts a schema instance" do
+      schema_class = Class.new(Dry::Schema::Params) do
+        define do
+          required(:name).filled(:string)
+        end
+      end
+
+      klass = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        params schema_class
+      end
+
+      expect(klass._params_schema).to be_a(schema_class)
+    end
+
+    it "raises error when called without arguments or block" do
+      expect {
+        Class.new(Dry::Operation) do
+          include Dry::Operation::Extensions::Params
+
+          params
+        end
+      }.to raise_error(ArgumentError, "params requires either a schema class or a block")
+    end
+
+    it "allows schema to be inherited by subclasses" do
+      parent = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        params do
+          required(:name).filled(:string)
+        end
+      end
+
+      child = Class.new(parent)
+
+      expect(child._params_schema).to eq(parent._params_schema)
+    end
+
+    it "allows subclass to override parent schema" do
+      parent = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        params do
+          required(:name).filled(:string)
+        end
+      end
+
+      child = Class.new(parent) do
+        params do
+          required(:email).filled(:string)
+        end
+      end
+
+      expect(child._params_schema).not_to eq(parent._params_schema)
+    end
+  end
+
+  describe "#validate_params" do
+    it "returns Success with input when no schema is defined" do
+      klass = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+      end
+
+      instance = klass.new
+      result = instance.validate_params(name: "John")
+
+      expect(result).to eq(Success(name: "John"))
+    end
+
+    it "returns Success with validated params when validation passes" do
+      klass = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        params do
+          required(:name).filled(:string)
+        end
+      end
+
+      instance = klass.new
+      result = instance.validate_params(name: "John")
+
+      expect(result).to eq(Success(name: "John"))
+    end
+
+    it "returns Failure with errors when validation fails" do
+      klass = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        params do
+          required(:name).filled(:string)
+        end
+      end
+
+      instance = klass.new
+      result = instance.validate_params(name: "")
+
+      expect(result).to be_a(Dry::Monads::Failure)
+      expect(result.failure).to eq([:invalid_params, {name: ["must be filled"]}])
+    end
+
+    it "coerces values according to schema" do
+      klass = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        params do
+          required(:age).value(:integer)
+        end
+      end
+
+      instance = klass.new
+      result = instance.validate_params(age: "25")
+
+      expect(result).to eq(Success(age: 25))
+    end
+  end
+
+  describe "method wrapping" do
+    it "validates params before calling the method" do
+      klass = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        params do
+          required(:name).filled(:string)
+        end
+
+        def call(input)
+          input
+        end
+      end
+
+      instance = klass.new
+      result = instance.call(name: "John")
+
+      expect(result).to eq(Success(name: "John"))
+    end
+
+    it "returns validation failure without executing method body" do
+      executed = false
+
+      klass = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        params do
+          required(:name).filled(:string)
+        end
+
+        define_method(:call) do |input|
+          executed = true
+          input
+        end
+      end
+
+      instance = klass.new
+      result = instance.call(name: "")
+
+      expect(result).to be_a(Dry::Monads::Failure)
+      expect(result.failure).to eq([:invalid_params, {name: ["must be filled"]}])
+      expect(executed).to be(false)
+    end
+
+    it "works with custom methods specified via operate_on" do
+      klass = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        operate_on :process
+
+        params do
+          required(:name).filled(:string)
+        end
+
+        def process(input)
+          input
+        end
+      end
+
+      instance = klass.new
+      result = instance.process(name: "John")
+
+      expect(result).to eq(Success(name: "John"))
+    end
+
+    it "validates custom methods when params is defined before the method" do
+      klass = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        operate_on :process
+
+        params do
+          required(:name).filled(:string)
+        end
+
+        def process(input)
+          input
+        end
+      end
+
+      instance = klass.new
+      result = instance.process(name: "")
+
+      expect(result).to be_a(Dry::Monads::Failure)
+      expect(result.failure).to eq([:invalid_params, {name: ["must be filled"]}])
+    end
+  end
+end