teckel 0.4.0 → 0.8.0

data/spec/operation/result_spec.rb

@@ -4,24 +4,39 @@ RSpec.describe Teckel::Operation::Result do
   let(:failure_value) { "some error" }
   let(:failed_result) { Teckel::Operation::Result.new(failure_value, false) }
 
-  let(:success_value) { "some error" }
-  let(:successful_result) { Teckel::Operation::Result.new(failure_value, true) }
+  let(:success_value) { "some success" }
+  let(:successful_result) { Teckel::Operation::Result.new(success_value, true) }
 
-  it { expect(successful_result.successful?).to be(true) }
-  it { expect(failed_result.successful?).to be(false) }
+  it { expect(successful_result.successful?).to eq(true) }
+  it { expect(failed_result.successful?).to eq(false) }
 
-  it { expect(successful_result.failure?).to be(false) }
-  it { expect(failed_result.failure?).to be(true) }
+  it { expect(successful_result.failure?).to eq(false) }
+  it { expect(failed_result.failure?).to eq(true) }
 
   it { expect(successful_result.value).to eq(success_value) }
   it { expect(failed_result.value).to eq(failure_value) }
 
   describe "#success" do
-    it { expect(successful_result.success).to eq(success_value) }
-
-    it { expect(failed_result.success).to eq(nil) }
-    it { expect(failed_result.success("other")).to eq("other") }
-    it { expect(failed_result.success { |value| "Failed: #{value}" } ).to eq("Failed: some error") }
+    it("on successful result, returns value") {
+      expect(successful_result.success).to eq(success_value)
+    }
+
+    describe "on failed result" do
+      it("with no fallbacks, returns nil") {
+        expect(failed_result.success).to eq(nil)
+      }
+      it("with default-argument, returns default-argument") {
+        expect(failed_result.success("other")).to eq("other")
+      }
+      it("with block, returns block return value") {
+        expect(failed_result.success { |value| "Failed: #{value}" } ).to eq("Failed: some error")
+      }
+      it("with default-argument and block given, returns default-argument, skips block") {
+        expect { |blk|
+          expect(failed_result.success("default", &blk)).to_not eq("default")
+        }.to(yield_control)
+      }
+    end
   end
 
   describe "#failure" do
@@ -29,6 +44,6 @@ RSpec.describe Teckel::Operation::Result do
 
     it { expect(successful_result.failure).to eq(nil) }
     it { expect(successful_result.failure("other")).to eq("other") }
-    it { expect(successful_result.failure { |value| "Failed: #{value}" } ).to eq("Failed: some error") }
+    it { expect(successful_result.failure { |value| "Failed: #{value}" } ).to eq("Failed: some success") }
   end
 end

data/spec/operation/results_spec.rb

@@ -3,27 +3,75 @@
 require 'support/dry_base'
 require 'support/fake_models'
 
-RSpec.describe Teckel::Operation do
-  context "with build in result object" do
-    class CreateUserWithResult
-      include Teckel::Operation
-
-      result!
-
-      input  Types::Hash.schema(name: Types::String, age: Types::Coercible::Integer)
-      output Types.Instance(User)
-      error  Types::Hash.schema(message: Types::String, errors: Types::Array.of(Types::Hash))
-
-      def call(input)
-        user = User.new(name: input[:name], age: input[:age])
-        if user.save
-          user
-        else
-          fail!(message: "Could not save User", errors: user.errors)
-        end
-      end
+class CreateUserWithResult
+  include Teckel::Operation
+
+  result!
+
+  input  Types::Hash.schema(name: Types::String, age: Types::Coercible::Integer)
+  output Types.Instance(User)
+  error  Types::Hash.schema(message: Types::String, errors: Types::Array.of(Types::Hash))
+
+  def call(input)
+    user = User.new(name: input[:name], age: input[:age])
+    if user.save
+      success! user
+    else
+      fail!(message: "Could not save User", errors: user.errors)
+    end
+  end
+end
+
+class CreateUserCustomResult
+  include Teckel::Operation
+
+  class MyResult
+    include Teckel::Result # makes sure this can be used in a Chain
+
+    def initialize(value, success, opts = {})
+      @value, @success, @opts = value, success, opts
     end
 
+    # implementing Teckel::Result
+    def successful?
+      @success
+    end
+
+    # implementing Teckel::Result
+    attr_reader :value
+
+    attr_reader :opts
+  end
+
+  result MyResult
+  result_constructor ->(value, success) { MyResult.new(value, success, time: Time.now.to_i) }
+
+  input  Types::Hash.schema(name: Types::String, age: Types::Coercible::Integer)
+  output Types.Instance(User)
+  error  Types::Hash.schema(message: Types::String, errors: Types::Array.of(Types::Hash))
+
+  def call(input)
+    user = User.new(name: input[:name], age: input[:age])
+    if user.save
+      success! user
+    else
+      fail!(message: "Could not save User", errors: user.errors)
+    end
+  end
+end
+
+class CreateUserOverwritingResult
+  include Teckel::Operation
+
+  class Result
+    include Teckel::Result # makes sure this can be used in a Chain
+
+    def initialize(value, success); end
+  end
+end
+
+RSpec.describe Teckel::Operation do
+  context "with build in result object" do
     specify "output" do
       result = CreateUserWithResult.call(name: "Bob", age: 23)
       expect(result).to be_a(Teckel::Result)
@@ -40,44 +88,6 @@ RSpec.describe Teckel::Operation do
   end
 
   context "using custom result" do
-    class CreateUserCustomResult
-      include Teckel::Operation
-
-      class MyResult
-        include Teckel::Result # makes sure this can be used in a Chain
-
-        def initialize(value, success, opts = {})
-          @value, @success, @opts = value, success, opts
-        end
-
-        # implementing Teckel::Result
-        def successful?
-          @success
-        end
-
-        # implementing Teckel::Result
-        attr_reader :value
-
-        attr_reader :opts
-      end
-
-      result MyResult
-      result_constructor ->(value, success) { result.new(value, success, time: Time.now.to_i) }
-
-      input  Types::Hash.schema(name: Types::String, age: Types::Coercible::Integer)
-      output Types.Instance(User)
-      error  Types::Hash.schema(message: Types::String, errors: Types::Array.of(Types::Hash))
-
-      def call(input)
-        user = User.new(name: input[:name], age: input[:age])
-        if user.save
-          user
-        else
-          fail!(message: "Could not save User", errors: user.errors)
-        end
-      end
-    end
-
     specify "output" do
       result = CreateUserCustomResult.call(name: "Bob", age: 23)
       expect(result).to be_a(CreateUserCustomResult::MyResult)
@@ -98,16 +108,6 @@ RSpec.describe Teckel::Operation do
   end
 
   context "overwriting Result" do
-    class CreateUserOverwritingResult
-      include Teckel::Operation
-
-      class Result
-        include Teckel::Result # makes sure this can be used in a Chain
-
-        def initialize(value, success); end
-      end
-    end
-
     it "uses the class definition" do
       expect(CreateUserOverwritingResult.result).to_not eq(Teckel::Operation::Result)
       expect(CreateUserOverwritingResult.result).to eq(CreateUserOverwritingResult::Result)