interaktor 0.2.0 → 0.3.0

data/spec/{interactor → interaktor}/context_spec.rb

@@ -1,5 +1,5 @@
 module Interaktor
-  describe Context do
+  RSpec.describe Context do
     describe ".build" do
       it "converts the given hash to a context" do
         context = described_class.build(foo: "bar")

data/spec/{interactor → interaktor}/hooks_spec.rb

@@ -1,7 +1,7 @@
 # rubocop:disable RSpec/ScatteredSetup
 
 module Interaktor
-  describe Hooks do
+  RSpec.describe Hooks do
     describe "#with_hooks" do
       def build_hooked(&block)
         hooked = Class.new.send(:include, Interaktor::Hooks)

data/spec/interaktor/organizer_spec.rb

@@ -0,0 +1,249 @@
+RSpec.describe Interaktor::Organizer do
+  it_behaves_like "lint", described_class
+
+  describe ".organize" do
+    let(:interaktor2) { instance_double(Interaktor) }
+    let(:interaktor3) { instance_double(Interaktor) }
+
+    it "sets interaktors given class arguments" do
+      organizer = FakeInteraktor.build_interaktor(type: described_class)
+
+      expect {
+        organizer.organize(interaktor2, interaktor3)
+      }.to change(organizer, :organized)
+             .from([])
+             .to([interaktor2, interaktor3])
+    end
+
+    it "sets interaktors given an array of classes" do
+      organizer = FakeInteraktor.build_interaktor(type: described_class)
+
+      expect {
+        organizer.organize([interaktor2, interaktor3])
+      }.to change(organizer, :organized)
+             .from([])
+             .to([interaktor2, interaktor3])
+    end
+
+    it "allows multiple organize calls" do
+      organizer = FakeInteraktor.build_interaktor(type: described_class)
+      interaktor4 = instance_double(Interaktor)
+
+      expect {
+        organizer.organize(interaktor2, interaktor3)
+        organizer.organize(interaktor4)
+      }.to change(organizer, :organized)
+             .from([])
+             .to([interaktor2, interaktor3, interaktor4])
+    end
+  end
+
+  describe ".organized" do
+    it "is empty by default" do
+      organizer = FakeInteraktor.build_interaktor(type: described_class)
+
+      expect(organizer.organized).to eq([])
+    end
+  end
+
+  describe "#call" do
+    it "calls each interaktor in order" do
+      organizer = FakeInteraktor.build_interaktor(type: described_class) do
+        input { required(:foo) }
+        success { required(:foo) }
+      end
+
+      interaktor1 = FakeInteraktor.build_interaktor("Interaktor1") do
+        input { required(:foo) }
+        success { required(:foo) }
+
+        def call
+          success!(foo: "bar")
+        end
+      end
+
+      interaktor2 = FakeInteraktor.build_interaktor("Interaktor2") do
+        input { required(:foo) }
+        success { required(:foo) }
+
+        def call
+          success!(foo: "baz")
+        end
+      end
+
+      interaktor3 = FakeInteraktor.build_interaktor("Interaktor3") do
+        input { required(:foo) }
+        success { required(:foo) }
+
+        def call
+          success!(foo: "wadus")
+        end
+      end
+
+      allow(organizer).to receive(:organized) {
+        [interaktor1, interaktor2, interaktor3]
+      }
+
+      expect(interaktor1).to receive(:call!).once.ordered.and_call_original
+      expect(interaktor2).to receive(:call!).once.ordered.and_call_original
+      expect(interaktor3).to receive(:call!).once.ordered.and_call_original
+
+      result = organizer.call(foo: "asdf")
+
+      expect(result.foo).to eq "wadus"
+    end
+
+    it "calls each interaktor in order and passes success attributes" do
+      organizer = FakeInteraktor.build_interaktor(type: described_class) { input { required(:foo) } }
+
+      interaktor1 = FakeInteraktor.build_interaktor("Interaktor1") do
+        input { required(:foo) }
+        success { required(:bar) }
+
+        def call
+          success!(bar: "baz")
+        end
+      end
+
+      interaktor2 = FakeInteraktor.build_interaktor("Interaktor1") do
+        input { required(:bar) }
+
+        def call
+          self.bar = "wadus"
+        end
+      end
+
+      allow(organizer).to receive(:organized) {
+        [interaktor1, interaktor2]
+      }
+
+      expect(interaktor1).to receive(:call!).once.ordered.and_call_original
+      expect(interaktor2).to receive(:call!).once.ordered.and_call_original
+
+      result = organizer.call(foo: "asdf")
+
+      expect(result.bar).to eq "wadus"
+    end
+
+    it "allows an interaktor to accept required attributes from previous success attributes" do
+      organizer = FakeInteraktor.build_interaktor(type: described_class)
+      interaktor1 = FakeInteraktor.build_interaktor("Interaktor1") do
+        success { required(:foo) }
+
+        def call
+          success!(foo: "whatever")
+        end
+      end
+      interaktor2 = FakeInteraktor.build_interaktor("Interaktor2") do
+        success { required(:bar) }
+
+        def call
+          success!(bar: "whatever")
+        end
+      end
+      interaktor3 = FakeInteraktor.build_interaktor("Interaktor3") do
+        input do
+          required(:foo)
+          required(:bar)
+        end
+      end
+
+      allow(organizer).to receive(:organized).and_return([interaktor1, interaktor2, interaktor3])
+
+      expect(interaktor1).to receive(:call!).once.ordered.and_call_original
+      expect(interaktor2).to receive(:call!).once.ordered.and_call_original
+      expect(interaktor3).to receive(:call!).once.ordered.and_call_original
+
+      organizer.call
+    end
+
+    it "allows an interaktor to accept required attributes from the original organizer" do
+      organizer = FakeInteraktor.build_interaktor(type: described_class) do
+        input do
+          required(:foo)
+          required(:bar)
+        end
+      end
+      interaktor1 = FakeInteraktor.build_interaktor("Interaktor1")
+      interaktor2 = FakeInteraktor.build_interaktor("Interaktor2") { input { required(:foo) } }
+      interaktor3 = FakeInteraktor.build_interaktor("Interaktor3") { input { required(:bar) } }
+
+      allow(organizer).to receive(:organized).and_return([interaktor1, interaktor2, interaktor3])
+
+      expect(interaktor1).to receive(:call!).once.ordered.and_call_original
+      expect(interaktor2).to receive(:call!).once.ordered.and_call_original
+      expect(interaktor3).to receive(:call!).once.ordered.and_call_original
+
+      organizer.call(foo: "whatever", bar: "baz")
+    end
+
+    it "allows an interaktor to accept required attributes from the original organizer AND previous success attributes" do
+      organizer = FakeInteraktor.build_interaktor(type: described_class) { input { required(:foo) } }
+      interaktor1 = FakeInteraktor.build_interaktor("Interaktor1") do
+        success { required(:bar) }
+
+        def call
+          success!(bar: "whatever")
+        end
+      end
+      interaktor2 = FakeInteraktor.build_interaktor("Interaktor2") do
+        success { required(:baz) }
+
+        def call
+          success!(baz: "whatever")
+        end
+      end
+      interaktor3 = FakeInteraktor.build_interaktor("Interaktor3") do
+        input do
+          required(:foo)
+          required(:bar)
+          required(:baz)
+        end
+      end
+
+      allow(organizer).to receive(:organized).and_return([interaktor1, interaktor2, interaktor3])
+
+      expect(interaktor1).to receive(:call!).once.ordered.and_call_original
+      expect(interaktor2).to receive(:call!).once.ordered.and_call_original
+      expect(interaktor3).to receive(:call!).once.ordered.and_call_original
+
+      organizer.call(foo: "whatever")
+    end
+
+    it "raises an exception if an interaktor requires an input attribute not provided by any previous interaktor" do
+      organizer = FakeInteraktor.build_interaktor(type: described_class)
+      interaktor1 = FakeInteraktor.build_interaktor("Interaktor1")
+      interaktor2 = FakeInteraktor.build_interaktor("Interaktor2") { input { required(:foo) } }
+
+      allow(organizer).to receive(:organized).and_return([interaktor1, interaktor2])
+
+      expect(interaktor1).not_to receive(:call!)
+
+      expect {
+        organizer.call
+      }.to raise_error(
+        an_instance_of(Interaktor::Error::OrganizerMissingPassedAttributeError)
+          .and(having_attributes(
+            attribute: :foo,
+            interaktor: interaktor2,
+          ))
+      )
+    end
+
+    it "raises an exception if the organizer's last interaktor does not include the organizer's success attributes" do
+      organizer = FakeInteraktor.build_interaktor(type: described_class) { success { required(:final) } }
+      interaktor1 = FakeInteraktor.build_interaktor("Interaktor1")
+
+      allow(organizer).to receive(:organized).and_return([interaktor1])
+
+      expect(interaktor1).not_to receive(:call!)
+
+      expect {
+        organizer.call
+      }.to raise_error(
+        an_instance_of(Interaktor::Error::OrganizerSuccessAttributeMissingError)
+          .and(having_attributes(attribute: :final, interaktor: interaktor1))
+      )
+    end
+  end
+end

data/spec/interaktor_spec.rb

@@ -1,3 +1,3 @@
-describe Interaktor do
-  include_examples "lint"
+RSpec.describe Interaktor do
+  it_behaves_like "lint", described_class
 end

data/spec/spec_helper.rb

@@ -1,3 +1,23 @@
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.filter_run_when_matching :focus
+  config.example_status_persistence_file_path = "spec/examples.txt"
+  config.disable_monkey_patching!
+  config.order = :random
+
+  config.default_formatter = "doc" if config.files_to_run.one?
+
+  Kernel.srand config.seed
+end
+
 require "simplecov"
 SimpleCov.start do
   enable_coverage :branch

data/spec/support/helpers.rb

@@ -0,0 +1,14 @@
+class FakeInteraktor
+  # @param name [String]
+  def self.build_interaktor(name = nil, type: Interaktor, &block)
+    name ||= "MyTest#{type}"
+
+    result = Class.new.include(type)
+
+    result.class_eval(&block) if block
+    result.define_singleton_method(:inspect) { name.to_s }
+    result.define_singleton_method(:to_s) { inspect }
+
+    result
+  end
+end

data/spec/support/lint.rb

@@ -1,10 +1,7 @@
-shared_examples "lint" do
-  let(:interaktor) { Class.new.include(described_class) }
-
+RSpec.shared_examples "lint" do |interaktor_class|
   describe ".call" do
-    let(:instance) { instance_double(interaktor) }
-
     it "calls an instance" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class)
       expect(interaktor).to receive(:new).once.with({}).and_call_original
 
       result = interaktor.call
@@ -12,13 +9,17 @@ shared_examples "lint" do
       expect(result.success?).to be true
     end
 
-    it "fails when an unknown attribute is provided" do
-      expect {
-        interaktor.call(baz: "wadus")
-      }.to raise_error(an_instance_of(Interaktor::Error::UnknownAttributeError).and having_attributes(attributes: [:baz]))
+    it "removes unknown provided attributes" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class)
+
+      result = interaktor.call(baz: "wadus")
+
+      expect(result.baz).to be nil
     end
 
     it "fails when a non-hash or non-context argument is passed" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class)
+
       expect {
         interaktor.call("foo")
       }.to raise_error(ArgumentError, /Expected a hash argument/)
@@ -26,9 +27,8 @@ shared_examples "lint" do
   end
 
   describe ".call!" do
-    let(:instance) { instance_double(interaktor) }
-
     it "calls an instance" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class)
       expect(interaktor).to receive(:new).once.with({}).and_call_original
 
       result = interaktor.call!
@@ -36,13 +36,17 @@ shared_examples "lint" do
       expect(result.success?).to be true
     end
 
-    it "fails when an unknown attribute is provided" do
-      expect {
-        interaktor.call!(baz: "wadus")
-      }.to raise_error(an_instance_of(Interaktor::Error::UnknownAttributeError).and having_attributes(attributes: [:baz]))
+    it "removes unknown provided attributes" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class)
+
+      result = interaktor.call!(baz: "wadus")
+
+      expect(result.baz).to be nil
     end
 
     it "fails when a non-hash or non-context argument is passed" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class)
+
       expect {
         interaktor.call!("foo")
       }.to raise_error(ArgumentError, /Expected a hash argument/)
@@ -50,15 +54,17 @@ shared_examples "lint" do
   end
 
   describe "#run" do
-    let(:instance) { interaktor.new }
-
     it "runs the interaktor" do
+      instance = FakeInteraktor.build_interaktor(type: interaktor_class).new
+
       expect(instance).to receive(:run!).once.with(no_args)
 
       instance.run
     end
 
     it "rescues failure" do
+      instance = FakeInteraktor.build_interaktor(type: interaktor_class).new
+
       expect(instance).to receive(:run!).and_raise(Interaktor::Failure)
 
       expect {
@@ -67,6 +73,8 @@ shared_examples "lint" do
     end
 
     it "raises other errors" do
+      instance = FakeInteraktor.build_interaktor(type: interaktor_class).new
+
       expect(instance).to receive(:run!).and_raise("foo")
 
       expect {
@@ -76,15 +84,17 @@ shared_examples "lint" do
   end
 
   describe "#run!" do
-    let(:instance) { interaktor.new }
-
     it "calls the interaktor" do
+      instance = FakeInteraktor.build_interaktor(type: interaktor_class).new
+
       expect(instance).to receive(:call).once.with(no_args)
 
       instance.run!
     end
 
     it "raises failure" do
+      instance = FakeInteraktor.build_interaktor(type: interaktor_class).new
+
       expect(instance).to receive(:run!).and_raise(Interaktor::Failure)
 
       expect {
@@ -93,6 +103,8 @@ shared_examples "lint" do
     end
 
     it "raises other errors" do
+      instance = FakeInteraktor.build_interaktor(type: interaktor_class).new
+
       expect(instance).to receive(:run!).and_raise("foo")
 
       expect {
@@ -102,9 +114,9 @@ shared_examples "lint" do
   end
 
   describe "#call" do
-    let(:instance) { interaktor.new }
-
     it "exists" do
+      instance = FakeInteraktor.build_interaktor(type: interaktor_class).new
+
       expect(instance).to respond_to(:call)
       expect { instance.call }.not_to raise_error
       expect { instance.method(:call) }.not_to raise_error
@@ -112,275 +124,500 @@ shared_examples "lint" do
   end
 
   describe "#rollback" do
-    let(:instance) { interaktor.new }
-
     it "exists" do
+      instance = FakeInteraktor.build_interaktor(type: interaktor_class).new
+
       expect(instance).to respond_to(:rollback)
       expect { instance.rollback }.not_to raise_error
       expect { instance.method(:rollback) }.not_to raise_error
     end
   end
 
-  describe "required attributes" do
-    let(:instance) { instance_double(interaktor) }
+  describe "#required_input_attributes" do
+    it "returns the attributes" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        input do
+          required(:foo)
+          required(:bar)
+          optional(:baz)
+        end
+      end
 
-    it "initializes successfully when the attribute is provided" do
-      interaktor.class_eval { required :bar }
+      expect(interaktor.required_input_attributes).to contain_exactly(:foo, :bar)
+    end
 
-      expect(interaktor).to receive(:new).once.with(bar: "baz").and_call_original
+    it "returns empty array when not defined" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class)
 
-      result = interaktor.call(bar: "baz")
+      expect(interaktor.required_input_attributes).to be_empty
+    end
+  end
 
-      expect(result.success?).to be true
-      expect(result.bar).to eq "baz"
+  describe "#optional_input_attributes" do
+    it "returns the attributes" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        input do
+          required(:foo)
+          required(:bar)
+          optional(:baz)
+        end
+      end
+
+      expect(interaktor.optional_input_attributes).to contain_exactly(:baz)
     end
 
-    it "creates a value setter" do
-      interaktor.class_eval { required :bar }
+    it "returns empty array when not defined" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class)
 
-      expect(interaktor).to receive(:new).once.with(bar: "baz").and_call_original
+      expect(interaktor.optional_input_attributes).to be_empty
+    end
+  end
 
-      interaktor.define_method(:call) do
-        self.bar = "wadus"
+  describe "#input_attributes" do
+    it "returns both required and optional attributes" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        input do
+          required(:foo)
+          required(:bar)
+          optional(:baz)
+        end
       end
 
-      result = interaktor.call(bar: "baz")
+      expect(interaktor.input_attributes).to contain_exactly(:foo, :bar, :baz)
+    end
+  end
 
-      expect(result.success?).to be true
-      expect(result.bar).to eq "wadus"
+  describe "#required_success_attributes" do
+    it "returns the attributes" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        success do
+          required(:foo)
+          required(:bar)
+          optional(:baz)
+        end
+      end
+
+      expect(interaktor.required_success_attributes).to contain_exactly(:foo, :bar)
     end
 
-    it "raises an exception when the attribute is not provided" do
-      interaktor.class_eval { required :bar }
+    it "returns empty array when not defined" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class)
 
-      expect {
-        interaktor.call!
-      }.to raise_error(an_instance_of(Interaktor::Error::MissingAttributeError).and having_attributes(attributes: [:bar]))
+      expect(interaktor.required_success_attributes).to be_empty
     end
+  end
 
-    describe "options" do
-      it "raises an exception when an unknown option is provided" do
-        expect {
-          interaktor.class_eval { required :bar, unknown: true }
-        }.to raise_error(an_instance_of(Interaktor::Error::UnknownOptionError).and having_attributes(options: { unknown: true }))
+  describe "#optional_success_attributes" do
+    it "returns the attributes" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        success do
+          required(:foo)
+          required(:bar)
+          optional(:baz)
+        end
       end
+
+      expect(interaktor.optional_success_attributes).to contain_exactly(:baz)
+    end
+
+    it "returns empty array when not defined" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class)
+
+      expect(interaktor.optional_success_attributes).to be_empty
     end
   end
 
-  describe "optional attributes" do
-    let(:instance) { instance_double(interaktor) }
+  describe "#success_attributes" do
+    it "returns both required and optional attributes" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        success do
+          required(:foo)
+          required(:bar)
+          optional(:baz)
+        end
+      end
 
-    it "initializes successfully when the attribute is provided" do
-      interaktor.class_eval { optional :bar }
+      expect(interaktor.success_attributes).to contain_exactly(:foo, :bar, :baz)
+    end
+  end
 
-      expect(interaktor).to receive(:new).once.with(bar: "baz").and_call_original
+  describe "#required_failure_attributes" do
+    it "returns the attributes" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        failure do
+          required(:foo)
+          required(:bar)
+          optional(:baz)
+        end
+      end
 
-      result = interaktor.call(bar: "baz")
+      expect(interaktor.required_failure_attributes).to contain_exactly(:foo, :bar)
+    end
 
-      expect(result.success?).to be true
-      expect(result.bar).to eq "baz"
+    it "returns empty array when not defined" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class)
+
+      expect(interaktor.required_failure_attributes).to be_empty
     end
+  end
 
-    it "initializes successfully when the attribute is not provided" do
-      interaktor.class_eval { optional :bar }
+  describe "#optional_failure_attributes" do
+    it "returns the attributes" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        failure do
+          required(:foo)
+          required(:bar)
+          optional(:baz)
+        end
+      end
 
-      expect(interaktor).to receive(:new).once.with({}).and_call_original
+      expect(interaktor.optional_failure_attributes).to contain_exactly(:baz)
+    end
 
-      result = interaktor.call
+    it "returns empty array when not defined" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class)
 
-      expect(result.success?).to be true
-      expect(result.bar).to be_nil
+      expect(interaktor.optional_failure_attributes).to be_empty
     end
+  end
 
-    it "creates a value setter" do
-      interaktor.class_eval { optional :bar }
+  describe "#failure_attributes" do
+    it "returns both required and optional attributes" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        failure do
+          required(:foo)
+          required(:bar)
+          optional(:baz)
+        end
+      end
 
-      expect(interaktor).to receive(:new).once.with(bar: "baz").and_call_original
+      expect(interaktor.failure_attributes).to contain_exactly(:foo, :bar, :baz)
+    end
+  end
 
-      interaktor.define_method(:call) do
-        self.bar = "wadus"
+  describe "input attributes" do
+    it "accepts a schema object" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        input(Dry::Schema.Params { required(:bar).filled(:string) })
       end
 
+      expect(interaktor.input_schema).to be_a Dry::Schema::Params
+      expect(interaktor.input_schema.info).to eq(
+        keys: { bar: { required: true, type: "string" } },
+      )
+
+      expect(interaktor.required_input_attributes).to contain_exactly(:bar)
+
       result = interaktor.call(bar: "baz")
 
       expect(result.success?).to be true
-      expect(result.bar).to eq "wadus"
+      expect(result.bar).to eq "baz"
     end
 
-    it "raises an exception when assigning a value to an optional parameter which was not originally provided" do
-      interaktor.class_eval { optional :bar }
+    it "accepts a schema definition block" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        input { required(:bar).filled(:string) }
+      end
 
-      expect(interaktor).to receive(:new).once.with({}).and_call_original
+      expect(interaktor.input_schema).to be_a Dry::Schema::Params
+      expect(interaktor.input_schema.info).to eq(
+        keys: { bar: { required: true, type: "string" } },
+      )
+
+      expect(interaktor.required_input_attributes).to contain_exactly(:bar)
+
+      result = interaktor.call(bar: "baz")
 
-      interaktor.define_method(:call) do
-        self.bar = "baz"
+      expect(result.success?).to be true
+      expect(result.bar).to eq "baz"
+    end
+
+    it "raises an exception when the attribute is required and not provided" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        input { required(:bar).filled(:string) }
       end
 
-      expect { interaktor.call }.to(
-        raise_error(
-          an_instance_of(Interaktor::Error::DisallowedAttributeAssignmentError)
-            .and(having_attributes(attributes: [:bar]))
+      expect {
+        interaktor.call!
+      }.to raise_error(
+        an_instance_of(Interaktor::Error::AttributeSchemaValidationError).and(
+          having_attributes(
+            interaktor: interaktor,
+            validation_errors: { bar: ["is missing"] },
+          )
         )
       )
     end
 
-    describe "options" do
-      it "accepts a default value for the attribute" do
-        interaktor.class_eval { optional :bar, default: "baz" }
+    it "removes unknown provided attributes" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        input { required(:bar).filled(:string) }
+      end
 
-        expect(interaktor).to receive(:new).once.with(bar: "baz").and_call_original
+      result = interaktor.call!(bar: "baz", foo: "unexpected")
 
-        result = interaktor.call
+      expect(result.foo).to be nil
+    end
 
-        expect(result.success?).to be true
-        expect(result.bar).to eq "baz"
+    it "allows provided optional attributes" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        input { optional(:bar).filled(:string) }
       end
 
-      it "raises an exception when an unknown option is provided" do
-        expect {
-          interaktor.class_eval { optional :bar, unknown: true }
-        }.to raise_error(an_instance_of(Interaktor::Error::UnknownOptionError).and having_attributes(options: { unknown: true }))
+      expect(interaktor.optional_input_attributes).to contain_exactly(:bar)
+
+      result = interaktor.call(bar: "baz")
+
+      expect(result.success?).to be true
+      expect(result.bar).to eq "baz"
+    end
+
+    it "allows missing optional attributes" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        input { optional(:bar).filled(:string) }
       end
+
+      expect(interaktor.optional_input_attributes).to contain_exactly(:bar)
+
+      result = interaktor.call
+
+      expect(result.success?).to be true
+      expect(result.bar).to be_nil
     end
-  end
 
-  describe "success attributes" do
-    it "succeeds when the correct attributes are provided" do
-      interaktor.class_eval { success :bar }
+    it "creates attribute getters and setters" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        input do
+          required(:foo).filled(:string)
+          optional(:bar).filled(:string)
+        end
 
-      expect(interaktor).to receive(:new).once.with({}).and_call_original
+        def call
+          foo
+          bar
 
-      interaktor.define_method(:call) do
-        success!(bar: "baz")
+          self.foo = "one"
+          self.bar = "two"
+        end
       end
 
-      result = interaktor.call
+      result = interaktor.call(foo: "bar", bar: "baz")
 
       expect(result.success?).to be true
-      expect(result.bar).to eq "baz"
+      expect(result.foo).to eq "one"
+      expect(result.bar).to eq "two"
     end
+  end
 
-    it "raises an exception when the correct attributes are not provided because #success! is not called" do
-      interaktor.class_eval { success :bar }
+  describe "success attributes" do
+    it "accepts a schema object" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        success(Dry::Schema.Params { required(:bar).filled(:string) })
 
-      expect(interaktor).to receive(:new).once.with({}).and_call_original
+        def call
+          success!(bar: "baz")
+        end
+      end
 
-      expect { interaktor.call }.to(
-        raise_error(
-          an_instance_of(Interaktor::Error::MissingAttributeError).and having_attributes(attributes: [:bar])
-        )
+      expect(interaktor.success_schema).to be_a Dry::Schema::Params
+      expect(interaktor.success_schema.info).to eq(
+        keys: { bar: { required: true, type: "string" } },
       )
-    end
 
-    it "raises an exception when the correct attributes are not provided in the call to #success!" do
-      interaktor.class_eval { success :bar }
+      expect(interaktor.required_success_attributes).to contain_exactly(:bar)
 
-      expect(interaktor).to receive(:new).once.with({}).and_call_original
+      result = interaktor.call
+
+      expect(result.success?).to be true
+      expect(result.bar).to eq "baz"
+    end
+
+    it "accepts a schema definition block" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        success { required(:bar).filled(:string) }
 
-      interaktor.define_method(:call) do
-        success!({})
+        def call
+          success!(bar: "baz")
+        end
       end
 
-      expect { interaktor.call }.to(
-        raise_error(
-          an_instance_of(Interaktor::Error::MissingAttributeError).and having_attributes(attributes: [:bar])
-        )
+      expect(interaktor.success_schema).to be_a Dry::Schema::Params
+      expect(interaktor.success_schema.info).to eq(
+        keys: { bar: { required: true, type: "string" } },
       )
-    end
 
-    it "raises an exception when unknown attributes are provided" do
-      interaktor.class_eval { success :bar }
+      expect(interaktor.required_success_attributes).to contain_exactly(:bar)
 
-      expect(interaktor).to receive(:new).once.with({}).and_call_original
+      result = interaktor.call
+
+      expect(result.success?).to be true
+      expect(result.bar).to eq "baz"
+    end
 
-      interaktor.define_method(:call) do
-        success!(bar: "baz", baz: "wadus")
+    it "raises an exception when the attribute is required and not provided" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        success { required(:bar).filled(:string) }
+
+        def call
+          success!
+        end
       end
 
-      expect { interaktor.call }.to(
-        raise_error(
-          an_instance_of(Interaktor::Error::UnknownAttributeError).and having_attributes(attributes: [:baz])
+      expect {
+        result = interaktor.call
+      }.to raise_error(
+        an_instance_of(Interaktor::Error::AttributeSchemaValidationError).and(
+          having_attributes(
+            interaktor: interaktor,
+            validation_errors: { bar: ["is missing"] },
+          )
         )
       )
     end
 
-    describe "options" do
-      it "raises an exception when an unknown option is provided" do
-        expect {
-          interaktor.class_eval { success :bar, unknown: true }
-        }.to raise_error(an_instance_of(Interaktor::Error::UnknownOptionError).and having_attributes(options: { unknown: true }))
+    it "removes unknown provided attributes" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        success { required(:bar).filled(:string) }
+
+        def call
+          success!(bar: "baz", foo: "wadus")
+        end
       end
-    end
-  end
 
-  describe "failure attributes" do
-    it "fails when the correct attributes are provided" do
-      interaktor.class_eval { failure :bar }
+      result = interaktor.call
 
-      expect(interaktor).to receive(:new).once.with({}).and_call_original
+      expect(result.foo).to be nil
+    end
 
-      interaktor.define_method(:call) do
-        fail!(bar: "baz")
+    it "allows missing optional attributes" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        success { optional(:bar).filled(:string) }
+
+        def call
+          success!
+        end
       end
 
+      expect(interaktor.optional_success_attributes).to contain_exactly(:bar)
+
       result = interaktor.call
 
-      expect(result.success?).to be false
-      expect(result.bar).to eq "baz"
+      expect(result.success?).to be true
+      expect(result.bar).to be nil
     end
 
-    it "raises an exception when the correct attributes are not provided" do
-      interaktor.class_eval { failure :bar }
-
-      expect(interaktor).to receive(:new).once.with({}).and_call_original
+    it "raises an exception when the correct attributes are not provided because #success! is not called" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        success { required(:bar).filled(:string) }
 
-      interaktor.define_method(:call) do
-        fail!({})
+        def call
+          # do nothing and succeed implicitly
+        end
       end
 
       expect { interaktor.call }.to(
         raise_error(
-          an_instance_of(Interaktor::Error::MissingAttributeError).and having_attributes(attributes: [:bar])
+          an_instance_of(Interaktor::Error::MissingExplicitSuccessError).and having_attributes(attributes: [:bar])
         )
       )
     end
+  end
 
-    context "when the interaktor is called with #call!" do
-      it "raises an exception when the correct attributes are provided" do
-        interaktor.class_eval { failure :bar }
-
-        expect(interaktor).to receive(:new).once.with({}).and_call_original
+  describe "failure attributes" do
+    it "accepts a schema object" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        failure(Dry::Schema.Params { required(:bar).filled(:string) })
 
-        interaktor.define_method(:call) do
+        def call
           fail!(bar: "baz")
         end
+      end
+
+      expect(interaktor.failure_schema).to be_a Dry::Schema::Params
+      expect(interaktor.failure_schema.info).to eq(
+        keys: { bar: { required: true, type: "string" } },
+      )
+
+      expect(interaktor.required_failure_attributes).to contain_exactly(:bar)
+
+      result = interaktor.call
+
+      expect(result.failure?).to be true
+      expect(result.bar).to eq "baz"
+    end
+
+    it "accepts a schema definition block" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        failure { required(:bar).filled(:string) }
 
-        expect { interaktor.call! }.to raise_error(Interaktor::Failure)
+        def call
+          fail!(bar: "baz")
+        end
       end
 
-      it "raises an exception when the correct attributes are not provided" do
-        interaktor.class_eval { failure :bar }
+      expect(interaktor.failure_schema).to be_a Dry::Schema::Params
+      expect(interaktor.failure_schema.info).to eq(
+        keys: { bar: { required: true, type: "string" } },
+      )
 
-        expect(interaktor).to receive(:new).once.with({}).and_call_original
+      expect(interaktor.required_failure_attributes).to contain_exactly(:bar)
 
-        interaktor.define_method(:call) do
-          fail!({})
+      result = interaktor.call
+
+      expect(result.failure?).to be true
+      expect(result.bar).to eq "baz"
+    end
+
+    it "raises an exception when the attribute is required and not provided" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        failure { required(:bar).filled(:string) }
+
+        def call
+          fail!
         end
+      end
 
-        expect { interaktor.call }.to(
-          raise_error(
-            an_instance_of(Interaktor::Error::MissingAttributeError).and having_attributes(attributes: [:bar])
+      expect {
+        result = interaktor.call
+      }.to raise_error(
+        an_instance_of(Interaktor::Error::AttributeSchemaValidationError).and(
+          having_attributes(
+            interaktor: interaktor,
+            validation_errors: { bar: ["is missing"] },
           )
         )
+      )
+    end
+
+    it "removes unknown provided attributes" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        failure { required(:bar).filled(:string) }
+
+        def call
+          fail!(bar: "baz", foo: "wadus")
+        end
       end
+
+      result = interaktor.call
+
+      expect(result.foo).to be nil
     end
 
-    describe "options" do
-      it "raises an exception when an unknown option is provided" do
-        expect {
-          interaktor.class_eval { failure :bar, unknown: true }
-        }.to raise_error(an_instance_of(Interaktor::Error::UnknownOptionError).and having_attributes(options: { unknown: true }))
+    it "allows missing optional attributes" do
+      interaktor = FakeInteraktor.build_interaktor(type: interaktor_class) do
+        failure { optional(:bar).filled(:string) }
+
+        def call
+          fail!
+        end
       end
+
+      expect(interaktor.optional_failure_attributes).to contain_exactly(:bar)
+
+      result = interaktor.call
+
+      expect(result.failure?).to be true
+      expect(result.bar).to be nil
     end
   end
 end