cross-stub 0.1.4 → 0.2.0

data/spec/includes.rb

@@ -0,0 +1,103 @@
+unless Object.const_defined?(:RUBY_VM)
+
+# ///////////////////////////////////////////////////////////////////////
+# Constants
+# ///////////////////////////////////////////////////////////////////////
+
+RUBY_VM = [
+  RUBY_VERSION.gsub(/[^\d]/,''),
+  RUBY_PLATFORM =~ /java/i ? 'j' : '',
+  RUBY_DESCRIPTION =~ /enterprise/i ? 'e' : ''
+].join
+
+PROJECT_ROOT = File.join(File.dirname(__FILE__), '..')
+PROJECT_FILE = lambda{|*args| File.join(*[PROJECT_ROOT, *args]) }
+
+CACHE_STORES = {
+  :file => PROJECT_FILE['tmp', "stubbing-#{RUBY_VM}.cache"],
+  :memcache => "localhost:11211/stubbing-#{RUBY_VM}.cache",
+  :redis => "localhost:6379/stubbing-#{RUBY_VM}.cache",
+}
+
+ECHO_SERVER_INIT_WAIT_TIME = RUBY_VM.end_with?('j') ? 10 : 2
+ECHO_SERVER_LOG = PROJECT_FILE['tmp', "echoserver-#{RUBY_VM}.log"]
+ECHO_SERVER_HOST = '127.0.0.1'
+ECHO_SERVER_PORT = 10000 + RUBY_VM[/(\d+)/,1].to_i + ({'j' => 7, 'e' => 17}[RUBY_VM[-1..-1]] || 0)
+
+# /////////////////////////////////////////////////////////////////////////////////////////
+# Useful methods
+# /////////////////////////////////////////////////////////////////////////////////////////
+
+def cache_store(id)
+  {(id = :"#{id}") => CACHE_STORES[id]}
+end
+
+def each_cache_store(&block)
+  CACHE_STORES.keys.each do |store_type|
+    yield(store_type)
+  end
+end
+
+def do_local_method_call(klass_and_method_and_args)
+  klass, is_instance, method, args = parse_call_args(klass_and_method_and_args)
+  receiver = is_instance ? klass.new : klass
+  args.empty? ? receiver.send(method) : receiver.send(method, *args)
+end
+
+def parse_call_args(klass_and_method_and_args)
+  klass_descriptor, method, *args = klass_and_method_and_args.split('.')
+  is_instance = klass_descriptor.end_with?(suffix = '#new')
+  [klassify(klass_descriptor), is_instance, method, args]
+end
+
+def do_remote_method_call(store_type_and_klass_and_method_and_args)
+  (value = EchoClient.get(store_type_and_klass_and_method_and_args)) !~ /^undefined method/ ?
+    value : Object.we_just_wanna_trigger_no_method_error_with_this_weird_method!
+end
+
+def klassify(descriptor)
+  descriptor.sub('#new','').split(/::/).inject(Object){|k,c| k.const_get(c) }
+end
+
+# /////////////////////////////////////////////////////////////////////////////////////////
+# Loading of files
+# /////////////////////////////////////////////////////////////////////////////////////////
+
+$LOAD_PATH.unshift(PROJECT_FILE['lib'])
+require 'cross-stub'
+
+# /////////////////////////////////////////////////////////////////////////////////////////
+# Class definitions for specs
+# /////////////////////////////////////////////////////////////////////////////////////////
+
+class AnyClass
+
+  def self.say ; 'hello' ; end
+
+  class Inner
+    def self.say ; 'hello' ; end
+  end
+
+end
+
+class AnyInstance
+
+  def say ; 'hello' ; end
+
+  class Inner
+    def say ; 'hello' ; end
+  end
+
+end
+
+module AnyModule
+
+  def self.say ; 'hello' ; end
+
+  module Inner
+    def self.say ; 'hello' ; end
+  end
+
+end
+
+end

data/spec/integration/clearing_instance_stubs_spec.rb

@@ -0,0 +1,119 @@
+require File.join(File.dirname(__FILE__), 'shared_spec')
+
+describe 'Clearing Instance Stubs' do
+
+  each_cache_store do |store_type|
+    %w{current other}.each do |mode|
+      %w{AnyInstance#new AnyInstance::Inner#new}.each do |descriptor|
+
+        describe '>> %s process using :%s store (%s instance)' % [mode, store_type, descriptor] do
+
+          before do
+            @descriptor = descriptor
+            @klass = klassify(descriptor)
+            @instance = @klass.new
+            @store_type = store_type
+          end
+
+          behaves_like "has #{mode} process setup"
+
+          should "clear hash generated stub and return original value" do
+            original_value = @instance.say
+            @klass.xstub({:say => 'HELLO'}, :instance => true)
+            CrossStub.clear
+            @call["#{@descriptor}.say"].should.equal original_value
+          end
+
+          should "clear hash generated stub and raise NoMethodError" do
+            should.raise(NoMethodError) do
+              @klass.xstub({:blurb => 'blah blah'}, :instance => true)
+              CrossStub.clear
+              @call["#{@descriptor}.blurb"]
+            end
+          end
+
+          should "clear symbol generated stub and return original value" do
+            original_value = @instance.say
+            @klass.xstub(:say, :instance => true)
+            CrossStub.clear
+            @call["#{@descriptor}.say"].should.equal original_value
+          end
+
+          should "clear symbol generated stub and raise NoMethodError" do
+            should.raise(NoMethodError) do
+              @klass.xstub(:blurb, :instance => true)
+              CrossStub.clear
+              @call["#{@descriptor}.blurb"]
+            end
+          end
+
+          should "clear block generated stub and return original value" do
+            original_value = @instance.say
+            @klass.xstub(:instance => true) do
+              def say ; 'HELLO' ; end
+            end
+            CrossStub.clear
+            @call["#{@descriptor}.say"].should.equal original_value
+          end
+
+          should "clear block generated stub and raise NoMethodError" do
+            should.raise(NoMethodError) do
+              @klass.xstub(:instance => true) do
+                def blurb ; 'blah blah' ; end
+              end
+              CrossStub.clear
+              @call["#{@descriptor}.blurb"]
+            end
+          end
+
+          should "always clear previously generated stub" do
+            original_value = @instance.say
+
+            # Stub an existing method
+            @klass.xstub({:say => 'HELLO'}, :instance => true)
+            @call["#{@descriptor}.say"]
+
+            # Clear stubs without refreshing another process
+            CrossStub.clear
+            CrossStub.setup(cache_store(@store_type))
+
+            # Stub a non-existing method
+            @klass.xstub({:blurb => 'blah blah'}, :instance => true)
+            @call["#{@descriptor}.blurb"]
+
+            # Make sure existing method returns to original method
+            @call["#{@descriptor}.say"].should.equal original_value
+          end
+
+          should "always clear previously generated stub and raise NoMethodError" do
+            # Stub a non-existing method
+            @klass.xstub({:blurb => 'blah blah'}, :instance => true)
+            @call["#{@descriptor}.blurb"]
+
+            # Clear stubs without refreshing another process
+            CrossStub.clear
+            CrossStub.setup(cache_store(@store_type))
+
+            # Stub an existing method
+            @klass.xstub({:say => 'HELLO'}, :instance => true)
+            @call["#{@descriptor}.say"]
+
+            # Make sure accessing non-existing method throws error
+            should.raise(NoMethodError) { @call["#{@descriptor}.blurb"] }
+          end
+
+          should "clear for method not implemented in ruby and return original value" do
+            Time.xstub(:day => 99, :instance => true)
+            CrossStub.clear
+            value = nil
+            should.not.raise(NoMethodError) { value = @call['Time#new.day'] }
+            value.should.not.equal 99
+          end
+
+        end
+
+      end
+    end
+  end
+
+end

data/spec/integration/clearing_stubs_spec.rb

@@ -0,0 +1,118 @@
+require File.join(File.dirname(__FILE__), 'shared_spec')
+
+describe 'Clearing Stubs' do
+
+  each_cache_store do |store_type|
+    %w{current other}.each do |mode|
+      %w{AnyClass AnyClass::Inner AnyModule AnyModule::Inner}.each do |descriptor|
+
+        describe '>> %s process using :%s store (%s)' % [mode, store_type, descriptor] do
+
+          before do
+            @descriptor = descriptor
+            @klass = klassify(descriptor)
+            @store_type = store_type
+          end
+
+          behaves_like "has #{mode} process setup"
+
+          should "clear hash generated stub and return original value" do
+            original_value = @klass.say
+            @klass.xstub(:say => 'HELLO')
+            CrossStub.clear
+            @call["#{@descriptor}.say"].should.equal original_value
+          end
+
+          should "clear hash generated stub and raise NoMethodError" do
+            should.raise(NoMethodError) do
+              @klass.xstub(:bang => 'OOPS')
+              CrossStub.clear
+              @call["#{@descriptor}.bang"]
+            end
+          end
+
+          should "clear symbol generated stub and return original value" do
+            original_value = @klass.say
+            @klass.xstub(:say)
+            CrossStub.clear
+            @call["#{@descriptor}.say"].should.equal original_value
+          end
+
+          should "clear symbol generated stub and raise NoMethodError" do
+            should.raise(NoMethodError) do
+              @klass.xstub(:bang)
+              CrossStub.clear
+              @call["#{@descriptor}.bang"]
+            end
+          end
+
+          should "clear block generated stub and return original value" do
+            original_value = @klass.say
+            @klass.xstub do
+              def say ; 'HELLO' ; end
+            end
+            CrossStub.clear
+            @call["#{@descriptor}.say"].should.equal original_value
+          end
+
+          should "clear block generated stub and raise NoMethodError" do
+            should.raise(NoMethodError) do
+              @klass.xstub do
+                def bang ; 'OOPS' ; end
+              end
+              CrossStub.clear
+              @call["#{@descriptor}.bang"]
+            end
+          end
+
+          should "always clear previously generated stub" do
+            original_value = @klass.say
+
+            # Stub an existing method
+            @klass.xstub(:say => 'HELLO')
+            @call["#{@descriptor}.say"]
+
+            # Clear stubs without refreshing another process
+            CrossStub.clear
+            CrossStub.setup(cache_store(@store_type))
+
+            # Stub a non-existing method
+            @klass.xstub(:bang => 'OOPS')
+            @call["#{@descriptor}.bang"]
+
+            # Make sure existing method returns to original method
+            @call["#{@descriptor}.say"].should.equal original_value
+          end
+
+          should "always clear previously generated stub and raise NoMethodError" do
+            # Stub a non-existing method
+            @klass.xstub(:bang => 'OOPS')
+            @call["#{@descriptor}.bang"]
+
+            # Clear stubs without refreshing another process
+            CrossStub.clear
+            CrossStub.setup(cache_store(@store_type))
+
+            # Stub an existing method
+            @klass.xstub(:say => 'HELLO')
+            @call["#{@descriptor}.say"]
+
+            # Make sure accessing non-existing method throws error
+            should.raise(NoMethodError) { @call["#{@descriptor}.bang"] }
+          end
+
+          should "clear for method not implemented in ruby and return original value" do
+            Time.xstub(:now => 'abc')
+            CrossStub.clear
+            value = nil
+            should.not.raise(NoMethodError) { value = @call['Time.now'] }
+            value.should.not.equal 'abc'
+          end
+
+        end
+
+      end
+    end
+  end
+
+end

data/spec/integration/creating_instance_stubs_spec.rb

@@ -0,0 +1,91 @@
+require File.join(File.dirname(__FILE__), 'shared_spec')
+
+describe 'Creating Instance Stubs' do
+
+  each_cache_store do |store_type|
+    %w{current other}.each do |mode|
+      %w{AnyInstance#new AnyInstance::Inner#new}.each do |descriptor|
+
+        describe '>> %s process using :%s store (%s)' % [mode, store_type, descriptor] do
+
+          before do
+            @descriptor = descriptor
+            @klass = klassify(descriptor)
+            @store_type = store_type
+          end
+
+          behaves_like "has #{mode} process setup"
+
+          should "create with hash argument(s)" do
+            @klass.xstub({:bang => 'OOPS', :say => 'HELLO'}, :instance => true)
+            @call["#{@descriptor}.bang"].should.equal 'OOPS'
+            @call["#{@descriptor}.say"].should.equal 'HELLO'
+          end
+
+          should "create with symbol argument(s)" do
+            @klass.xstub(:bang, :instance => true)
+            @call["#{@descriptor}.bang"].should.equal nil
+          end
+
+          should "create with block with no argument" do
+            @klass.xstub(:instance => true) do
+              def bang ; 'OOPS' ; end
+            end
+            @call["#{@descriptor}.bang"].should.equal 'OOPS'
+          end
+
+          should "create with symbol & block with no argument" do
+            @klass.xstub(:bang, :instance => true) do
+              def say ; 'HELLO' ; end
+            end
+            @call["#{@descriptor}.bang"].should.equal nil
+            @call["#{@descriptor}.say"].should.equal 'HELLO'
+          end
+
+          should "create with hash & block with no argument" do
+            @klass.xstub({:bang => 'OOPS'}, :instance => true) do
+              def say ; 'HELLO' ; end
+            end
+            @call["#{@descriptor}.bang"].should.equal 'OOPS'
+            @call["#{@descriptor}.say"].should.equal 'HELLO'
+          end
+
+          should "always create the most recent" do
+            found, expected = [], ['OOPS', 'OOOPS', 'OOOOPS']
+            stub_and_get_value = lambda do |value|
+              @klass.xstub({:bang => value}, :instance => true)
+              @call["#{@descriptor}.bang"]
+            end
+
+            found << stub_and_get_value[expected[0]]
+            found << stub_and_get_value[expected[1]]
+
+            CrossStub.clear
+            CrossStub.setup(cache_store(@store_type))
+
+            found << stub_and_get_value[expected[2]]
+            found.should.equal expected
+          end
+
+          should "create stub with dependency on other stub" do
+            @klass.xstub({:something => 'HELLO'}, :instance => true) do
+              def do_action(who, action)
+                %\#{who} #{action} #{something}\
+              end
+            end
+            @call["#{@descriptor}.do_action.i.say"].should.equal 'i say HELLO'
+          end
+
+          should "create for method not implemented in ruby" do
+            day = 99
+            Time.xstub({:day => day}, :instance => true)
+            @call['Time#new.day'].should.equal day
+          end
+
+        end
+
+      end
+    end
+  end
+
+end

data/spec/integration/creating_stubs_spec.rb

@@ -0,0 +1,95 @@
+require File.join(File.dirname(__FILE__), 'shared_spec')
+
+describe 'Creating Stubs' do
+
+  each_cache_store do |store_type|
+    %w{current other}.each do |mode|
+      %w{AnyClass AnyModule AnyClass::Inner AnyModule::Inner}.each do |descriptor|
+
+          describe '>> %s process using :%s store (%s)' % [mode, store_type, descriptor] do
+
+            before do
+              @descriptor = descriptor
+              @klass = klassify(descriptor)
+              @store_type = store_type
+            end
+
+            behaves_like "has #{mode} process setup"
+
+            should "create with hash argument(s)" do
+              @klass.xstub(:bang => 'OOPS', :say => 'HELLO')
+              @call["#{@descriptor}.bang"].should.equal 'OOPS'
+              @call["#{@descriptor}.say"].should.equal 'HELLO'
+            end
+
+            should "create with symbol argument(s)" do
+              @klass.xstub(:bang)
+              @call["#{@descriptor}.bang"].should.equal nil
+            end
+
+            should "create with block with no argument" do
+              @klass.xstub do
+                def bang ; 'OOPS' ; end
+              end
+              @call["#{@descriptor}.bang"].should.equal 'OOPS'
+            end
+
+            should "create with symbol & block with no argument" do
+              @klass.xstub(:bang) do
+                def say
+                  'HELLO'
+                end
+              end
+              @call["#{@descriptor}.bang"].should.equal nil
+              @call["#{@descriptor}.say"].should.equal 'HELLO'
+            end
+
+            should "create with hash & block with no argument" do
+              @klass.xstub(:bang => 'OOPS') do
+                def say
+                  'HELLO'
+                end
+              end
+              @call["#{@descriptor}.bang"].should.equal 'OOPS'
+              @call["#{@descriptor}.say"].should.equal 'HELLO'
+            end
+
+            should "always create the most recent" do
+              found, expected = [], ['OOPS', 'OOOPS', 'OOOOPS']
+              stub_and_get_value = lambda do |value|
+                @klass.xstub(:bang => value)
+                @call["#{@descriptor}.bang"]
+              end
+
+              found << stub_and_get_value[expected[0]]
+              found << stub_and_get_value[expected[1]]
+
+              CrossStub.clear
+              CrossStub.setup(cache_store(@store_type))
+
+              found << stub_and_get_value[expected[2]]
+              found.should.equal expected
+            end
+
+            should "create stub with dependency on other stub" do
+              @klass.xstub(:something => 'HELLO') do
+                def do_action(who, action)
+                  %\#{who} #{action} #{something}\
+                end
+              end
+              @call["#{@descriptor}.do_action.i.say"].should.equal 'i say HELLO'
+            end
+
+            should "create for method not implemented in ruby" do
+              now = Time.now - 365*60*60*24
+              Time.xstub(:now => now)
+              @call['Time.now'].should.equal now
+            end
+
+          end
+
+      end
+    end
+  end
+
+end