Add integration tests for Params extension

Adds comprehensive integration tests demonstrating real-world usage:
- Validating operation inputs with success and failure scenarios
- Value coercion according to schema types  
- Nested structure validation with detailed error reporting
- Custom wrapped methods via operate_on
- Schema inheritance from parent classes

Author: aaronmallen

spec/integration/extensions/params_spec.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Dry::Operation::Extensions::Params do
+  include Dry::Monads[:result]
+
+  describe "validating operation inputs" do
+    it "validates params and allows operation to proceed on success" do
+      create_user = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        params do
+          required(:name).filled(:string)
+          required(:email).filled(:string)
+          optional(:age).maybe(:integer)
+        end
+
+        def call(input)
+          user = step create_user_record(input)
+          step send_welcome_email(user)
+          user
+        end
+
+        private
+
+        def create_user_record(attrs)
+          Success(attrs.merge(id: 1))
+        end
+
+        def send_welcome_email(_user)
+          Success(true)
+        end
+      end
+
+      result = create_user.new.call(name: "John Doe", email: "[email protected]", age: 25)
+
+      expect(result).to be_success
+      expect(result.value!).to eq(id: 1, name: "John Doe", email: "[email protected]", age: 25)
+    end
+
+    it "returns validation failure before executing operation logic" do
+      executed_steps = []
+
+      create_user = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        params do
+          required(:name).filled(:string)
+          required(:email).filled(:string)
+        end
+
+        define_method(:call) do |input|
+          executed_steps << :call_started
+          user = step create_user_record(input)
+          executed_steps << :user_created
+          user
+        end
+
+        define_method(:create_user_record) do |attrs|
+          executed_steps << :create_user_record
+          Success(attrs.merge(id: 1))
+        end
+      end
+
+      result = create_user.new.call(name: "", email: "invalid")
+
+      expect(result).to be_failure
+      expect(result.failure).to eq([:invalid_params, {name: ["must be filled"]}])
+      expect(executed_steps).to be_empty
+    end
+
+    it "coerces input values according to schema" do
+      calculate = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        params do
+          required(:x).value(:integer)
+          required(:y).value(:integer)
+        end
+
+        def call(input)
+          input[:x] + input[:y]
+        end
+      end
+
+      result = calculate.new.call(x: "10", y: "20")
+
+      expect(result).to be_success
+      expect(result.value!).to eq(30)
+    end
+  end
+
+  describe "with nested schemas" do
+    it "validates nested structures" do
+      create_order = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        params do
+          required(:customer).hash do
+            required(:name).filled(:string)
+            required(:email).filled(:string)
+          end
+          required(:items).array(:hash) do
+            required(:product_id).filled(:integer)
+            required(:quantity).filled(:integer)
+          end
+        end
+
+        def call(input)
+          input
+        end
+      end
+
+      result = create_order.new.call(
+        customer: {name: "John", email: "[email protected]"},
+        items: [
+          {product_id: 1, quantity: 2},
+          {product_id: 2, quantity: 1}
+        ]
+      )
+
+      expect(result).to be_success
+    end
+
+    it "returns detailed validation errors for nested structures" do
+      create_order = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        params do
+          required(:customer).hash do
+            required(:name).filled(:string)
+            required(:email).filled(:string)
+          end
+        end
+
+        def call(input)
+          input
+        end
+      end
+
+      result = create_order.new.call(customer: {name: "", email: ""})
+
+      expect(result).to be_failure
+      failure_type, errors = result.failure
+      expect(failure_type).to eq(:invalid_params)
+      expect(errors[:customer]).to include(:name, :email)
+    end
+  end
+
+  describe "with custom methods via operate_on" do
+    it "validates params for custom wrapped methods" do
+      processor = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        operate_on :process, :transform
+
+        params do
+          required(:value).filled(:string)
+        end
+
+        def process(input)
+          input[:value].upcase
+        end
+
+        def transform(input)
+          input[:value].downcase
+        end
+      end
+
+      instance = processor.new
+
+      result = instance.process(value: "hello")
+      expect(result).to eq(Success("HELLO"))
+
+      result = instance.transform(value: "WORLD")
+      expect(result).to eq(Success("world"))
+
+      result = instance.process(value: "")
+      expect(result).to be_failure
+      expect(result.failure).to eq([:invalid_params, {value: ["must be filled"]}])
+    end
+  end
+
+  describe "with schema classes" do
+    it "accepts a pre-defined schema class" do
+      user_schema = Dry::Schema.Params do
+        required(:name).filled(:string)
+        required(:email).filled(:string)
+        optional(:age).maybe(:integer)
+      end
+
+      create_user = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        params user_schema
+
+        def call(input)
+          input
+        end
+      end
+
+      result = create_user.new.call(name: "Alice", email: "[email protected]")
+      expect(result).to be_success
+      expect(result.value!).to include(name: "Alice", email: "[email protected]")
+
+      result = create_user.new.call(name: "", email: "invalid")
+      expect(result).to be_failure
+      expect(result.failure.first).to eq(:invalid_params)
+    end
+
+    it "allows schema reuse across multiple operations" do
+      shared_schema = Dry::Schema.Params do
+        required(:user_id).filled(:integer)
+        required(:action).filled(:string)
+      end
+
+      audit_operation = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        params shared_schema
+
+        def call(input)
+          "Audited: #{input[:action]} by user #{input[:user_id]}"
+        end
+      end
+
+      log_operation = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        params shared_schema
+
+        def call(input)
+          "Logged: #{input[:action]} by user #{input[:user_id]}"
+        end
+      end
+
+      result = audit_operation.new.call(user_id: 1, action: "login")
+      expect(result).to be_success
+      expect(result.value!).to eq("Audited: login by user 1")
+
+      result = log_operation.new.call(user_id: 2, action: "logout")
+      expect(result).to be_success
+      expect(result.value!).to eq("Logged: logout by user 2")
+    end
+  end
+
+  describe "inheritance" do
+    it "inherits params schema from parent class" do
+      base_operation = Class.new(Dry::Operation) do
+        include Dry::Operation::Extensions::Params
+
+        params do
+          required(:name).filled(:string)
+        end
+      end
+
+      child_operation = Class.new(base_operation) do
+        def call(input)
+          "Hello, #{input[:name]}!"
+        end
+      end
+
+      result = child_operation.new.call(name: "Alice")
+      expect(result).to be_success
+      expect(result.value!).to eq("Hello, Alice!")
+
+      result = child_operation.new.call(name: "")
+      expect(result).to be_failure
+    end
+  end
+end