Expand receive to handle blocks and exceptions.

Author: ioquatix

lib/sus/receive.rb

@@ -7,17 +7,16 @@
 
 module Sus
 	class Receive
-		CALL_ORIGINAL = Object.new
-
-		def initialize(base, method)
+		def initialize(base, method, &block)
 			@base = base
 			@method = method
 
 			@times = Times.new
 			@arguments = nil
 			@options = nil
 			@block = nil
-			@returning = CALL_ORIGINAL
+			
+			@returning = block
 		end
 
 		def print(output)
@@ -60,12 +59,27 @@ def with_call_count(predicate)
 			return self
 		end
 
-		def and_return(*returning)
-			if returning.size == 1
-				@returning = returning.first
+		def and_return(*returning, &block)
+			if block_given?
+				if returning.any?
+					raise ArgumentError, "Cannot specify both a block and returning values."
+				end
+				
+				@returning = block
+			elsif returning.size == 1
+				@returning = proc{returning.first}
 			else
-				@returning = returning
+				@returning = proc{returning}
+			end
+			
+			return self
+		end
+		
+		def and_raise(...)
+			@returning = proc do
+				raise(...)
 			end
+			
 			return self
 		end
 
@@ -97,7 +111,7 @@ def call(assertions, subject)
 
 						validate(mock, assertions, arguments, options, block)
 
-						next @returning
+						next @returning.call(*arguments, **options, &block)
 					end
 				end
 
@@ -110,7 +124,7 @@ def call(assertions, subject)
 		end
 
 		def call_original?
-			@returning == CALL_ORIGINAL
+			@returning.nil?
 		end
 
 		class WithArguments
@@ -128,7 +142,7 @@ def call(assertions, subject)
 				end
 			end
 		end
-
+		
 		class WithOptions
 			def initialize(predicate)
 				@predicate = predicate
@@ -153,15 +167,15 @@ def initialize(predicate)
 			def print(output)
 				output.write("with block", @predicate)
 			end
-
+			
 			def call(assertions, subject)
 				assertions.nested(self) do |assertions|
 
 					Expect.new(assertions, subject).not.to(Be == nil)
 				end
 			end
 		end
-
+		
 		class Times
 			ONCE = Be.new(:==, 1)
 
@@ -172,7 +186,7 @@ def initialize(condition = ONCE)
 			def print(output)
 				output.write("with call count ", @condition)
 			end
-
+			
 			def call(assertions, subject)
 				assertions.nested(self) do |assertions|
 					Expect.new(assertions, subject).to(@condition)
@@ -182,8 +196,8 @@ def call(assertions, subject)
 	end
 
 	class Base
-		def receive(method)
-			Receive.new(self, method)
+		def receive(method, &block)
+			Receive.new(self, method, &block)
 		end
 	end
 end

test/sus/mock.rb

@@ -45,6 +45,19 @@ def implementation(*arguments)
 		expect(interface.implementation).to be == 10
 	end
 
+	it "can expect a method to be called and call a block" do
+		expect(interface).to receive(:implementation){|*arguments|
+			"Called with arguments: #{arguments.first}"
+		}
+		
+		expect(interface.implementation(10)).to be == "Called with arguments: 10"
+	end
+	
+	it "can expect a method to be called and raise an exception" do
+		expect(interface).to receive(:implementation).and_raise(RuntimeError, "An error occurred")
+		expect{interface.implementation}.to raise_exception(RuntimeError, message: be =~ /An error occurred/)
+	end
+	
 	it "can replace a method on an object" do
 		mock(interface) do |mock|
 			mock.replace(:implementation) do

test/sus/receive.rb

@@ -23,29 +23,58 @@ def implementation(*arguments, **options)
 
 describe Sus::Receive do
 	let(:interface) {Interface.new}
-
-	it "can replace a method on an object" do
-		expect(interface).to receive(:implementation).and_return(FakeImplementation.new)
-
+	
+	it "can validate a method call" do
+		expect(interface).to receive(:implementation)
 		expect(interface).to be(:kind_of?, Interface)
-		expect(interface.implementation).to be(:kind_of?, FakeImplementation)
+		expect(interface.implementation).to be(:kind_of?, RealImplementation)
 	end
-
+	
+	with "#and_return" do
+		it "can return a specific value" do
+			expect(interface).to receive(:implementation).and_return(FakeImplementation.new)
+			
+			expect(interface).to be(:kind_of?, Interface)
+			expect(interface.implementation).to be(:kind_of?, FakeImplementation)
+		end
+		
+		it "can return multiple values" do
+			expect(interface).to receive(:implementation).and_return(true, false)
+			
+			expect(interface).to be(:kind_of?, Interface)
+			expect(interface.implementation).to be == [true, false]
+		end
+		
+		it "can return a block" do
+			expect(interface).to receive(:implementation).and_return{|value| "Block Result: #{value}"}
+			
+			expect(interface).to be(:kind_of?, Interface)
+			expect(interface.implementation(10)).to be == "Block Result: 10"
+		end
+	end
+	
+	with "#and_raise" do
+		it "can raise an error when the method is called" do
+			expect(interface).to receive(:implementation).and_raise("Error!")
+			expect{interface.implementation}.to raise_exception(RuntimeError, message: be =~ /Error!/)
+		end
+	end
+	
 	it "can validate arguments" do
 		expect(interface).to receive(:implementation).with(:foo, :bar)
-
+		
 		interface.implementation(:foo, :bar)
 	end
 
 	it "can validate (not) arguments" do
 		expect(interface).not.to receive(:implementation).with(:foo, :bar)
-
+		
 		interface.implementation(:foo, :bar2)
 	end
 
 	it "can validate options" do
 		expect(interface).to receive(:implementation).with(x: 1, y: 2)
-
+		
 		interface.implementation(x: 1, y: 2)
 	end
 end