interaktor 0.2.0 → 0.4.0

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