mcmire-rr 1.0.5.rc1

data/spec/api/spy/spy_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe "spy" do
+  attr_reader :subject
+  before(:each) do
+    @subject = Object.new
+    extend RR::Adapters::RRMethods
+  end
+
+  after(:each) do
+    RR.reset
+  end
+
+  it "should record all method invocations" do
+    subject = Object.new
+
+    def subject.something
+    end
+
+    def subject.something_else
+    end
+
+    spy(subject)
+
+    subject.something
+    subject.something_else
+    subject.to_s
+
+    received(subject).something.call
+    received(subject).something_else.call
+    received(subject).to_s.call
+  end
+
+  describe "RR recorded_calls" do
+    it "should verify method calls after the fact" do
+      stub(subject).pig_rabbit
+      subject.pig_rabbit("bacon", "bunny meat")
+      #subject.should have_received.pig_rabitt("bacon", "bunny meat")
+      received(subject).pig_rabbit("bacon", "bunny meat").call
+    end
+
+    it "should verify method calls after the fact" do
+      stub(subject).pig_rabbit
+      lambda do
+        received(subject).pig_rabbit("bacon", "bunny meat").call
+      end.should raise_error(RR::Errors::SpyVerificationErrors::SpyVerificationError)
+    end
+  end
+end

data/spec/api/strong/strong_spec.rb

@@ -0,0 +1,87 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+class StrongSpecFixture
+  def method_with_no_arguments
+  end
+
+  def method_with_one_argument(string)
+  end
+
+  def method_with_two_arguments(string, integer)
+  end
+
+  def method_with_three_arguments_including_varargs(string, integer, *args)
+  end
+
+  def method_with_varargs(*args)
+  end
+end
+
+describe "strong" do
+  attr_reader :subject
+  before(:each) do
+    @subject = Object.new
+    extend RR::Adapters::RRMethods
+  end
+
+  after(:each) do
+    RR.reset
+  end
+
+  context "when the method does not exist" do
+    it "raises an exception" do
+      lambda do
+        strong.stub(StrongSpecFixture.new).something
+      end.should raise_error(RR::Errors::SubjectDoesNotImplementMethodError)
+    end
+  end
+
+  context "when the method exists with no arguments" do
+    it "does not raise an exception" do
+      strong.stub(StrongSpecFixture.new).method_with_no_arguments
+    end
+  end
+
+  context "when the method has a different arity" do
+    it "raises an exception" do
+      lambda do
+        strong.stub(StrongSpecFixture.new).method_with_one_argument
+      end.should raise_error(RR::Errors::SubjectHasDifferentArityError)
+    end
+  end
+
+  context "when the method has accepts a variable number of arguments" do
+    it "does not raise an exception" do
+      strong.stub(StrongSpecFixture.new).method_with_varargs
+    end
+  end
+
+  context "when the method does not provide the required parameters before varargs" do
+    it "raises an exception" do
+      lambda do
+        strong.stub(StrongSpecFixture.new).method_with_three_arguments_including_varargs
+      end.should raise_error(RR::Errors::SubjectHasDifferentArityError)
+    end
+  end
+
+  context "when the minimum number of parameters are provided" do
+    it "does not raise an exception" do
+      strong.stub(StrongSpecFixture.new).method_with_three_arguments_including_varargs("one", 2)
+    end
+  end
+
+  context "when using instance_of and the method does not exist" do
+    it "raises an exception" do
+      lambda do
+        strong.stub.instance_of(StrongSpecFixture).something
+        StrongSpecFixture.new
+      end.should raise_error(RR::Errors::SubjectDoesNotImplementMethodError)
+    end
+  end
+
+  context "when using instance_of and the method does exist" do
+    it "does not raise an exception" do
+      strong.stub.instance_of(StrongSpecFixture).method_with_no_arguments
+    end
+  end
+end

data/spec/api/stub/stub_spec.rb

@@ -0,0 +1,152 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+class StubSpecFixture
+  attr_reader :initialize_arguments
+
+  def initialize(*args)
+    @initialize_arguments = args
+    yield if block_given?
+    method_run_in_initialize
+  end
+
+  def method_run_in_initialize
+
+  end
+end
+
+describe "stub" do
+  attr_reader :subject
+  before(:each) do
+    @subject = Object.new
+    extend RR::Adapters::RRMethods
+  end
+
+  after(:each) do
+    RR.reset
+  end
+
+  it "stubs via inline call" do
+    stub(subject).to_s {"a value"}
+    subject.to_s.should == "a value"
+  end
+
+  describe ".once.ordered" do
+    it "returns the values in the ordered called" do
+      stub(subject).to_s {"value 1"}.once.ordered
+      stub(subject).to_s {"value 2"}.once.ordered
+
+      subject.to_s.should == "value 1"
+      subject.to_s.should == "value 2"
+    end
+  end
+
+  context "when the subject is a proxy for the object with the defined method" do
+    it "stubs the method on the proxy object" do
+      proxy_target = Class.new {def foobar; :original_foobar; end}.new
+      proxy = Class.new do
+        def initialize(target)
+          @target = target
+        end
+
+        instance_methods.each do |m|
+          unless m =~ /^_/ || m.to_s == 'object_id' || m.to_s == 'method_missing'
+            alias_method "__blank_slated_#{m}", m
+            undef_method m
+          end
+        end
+
+        def method_missing(method_name, *args, &block)
+          @target.send(method_name, *args, &block)
+        end
+      end.new(proxy_target)
+      proxy.methods.should =~ proxy_target.methods
+
+      stub(proxy).foobar {:new_foobar}
+      proxy.foobar.should == :new_foobar
+    end
+  end
+
+  it "stubs via block with argument" do
+    stub subject do |d|
+      d.to_s {"a value"}
+      d.to_sym {:crazy}
+    end
+    subject.to_s.should == "a value"
+    subject.to_sym.should == :crazy
+  end
+
+  it "stubs via block without argument" do
+    stub subject do
+      to_s {"a value"}
+      to_sym {:crazy}
+    end
+    subject.to_s.should == "a value"
+    subject.to_sym.should == :crazy
+  end
+
+  it "stubs instance_of" do
+    stub.instance_of(StubSpecFixture) do |o|
+      o.to_s {"High Level Spec"}
+    end
+    StubSpecFixture.new.to_s.should == "High Level Spec"
+  end
+
+  it "stubs methods without letters" do
+    stub(subject).__send__(:==) {:equality}
+    (subject == 55).should == :equality
+  end
+
+  it "stubs methods invoked in #initialize while passing along the #initialize arg" do
+    method_run_in_initialize_stubbed = false
+    stub.instance_of(StubSpecFixture) do |o|
+      o.method_run_in_initialize {method_run_in_initialize_stubbed = true}
+    end
+    StubSpecFixture.new
+    method_run_in_initialize_stubbed.should be_true
+  end
+
+  it "passed the arguments and block passed to #initialize" do
+    block_called = false
+    stub.instance_of(StubSpecFixture) do |o|
+      o.method_run_in_initialize
+    end
+    instance = StubSpecFixture.new(1, 2) {block_called = true}
+    instance.initialize_arguments.should == [1, 2]
+    block_called.should be_true
+  end
+
+  context "mock then stub" do
+    it "stubs any calls not matching the mock" do
+      mock(subject).foobar(3) {:baz3}
+      stub(subject).foobar {:baz}
+      subject.foobar(3).should == :baz3
+      subject.foobar(4).should == :baz
+    end
+  end
+
+  context "stub that yields" do
+    context "when yields called without any arguments" do
+      it "yields only once" do
+        called_from_block = mock!.foo.once.subject
+        block_caller = stub!.bar.yields.subject
+        block_caller.bar { called_from_block.foo }
+      end
+    end
+
+    context "when yields called with an argument" do
+      it "yields only once" do
+        called_from_block = mock!.foo(1).once.subject
+        block_caller = stub!.bar.yields(1).subject
+        block_caller.bar { |argument| called_from_block.foo(argument) }
+      end
+    end
+
+    context "when yields calls are chained" do
+      it "yields several times" do
+        called_from_block = mock!.foo(1).once.then.foo(2).once.subject
+        block_caller = stub!.bar.yields(1).yields(2).subject
+        block_caller.bar { |argument| called_from_block.foo(argument) }
+      end
+    end
+  end
+end

data/spec/core_spec_suite.rb

@@ -0,0 +1,18 @@
+require "#{File.dirname(__FILE__)}/spec_helper"
+
+class CoreExampleSuite
+  def run
+    files = Dir["#{File.dirname(__FILE__)}/**/*_spec.rb"]
+    files.delete_if {|file| file.include?('rspec/')}
+    files.delete_if {|file| file.include?('test_unit/')}
+    puts "Running Rspec Example Suite"
+    files.each do |file|
+      require File.expand_path(file)
+#      puts "require '#{file}'"
+    end
+  end
+end
+
+if $0 == __FILE__
+  CoreExampleSuite.new.run
+end

data/spec/environment_fixture_setup.rb

@@ -0,0 +1,7 @@
+require "rubygems"
+require "rspec"
+require "bundler"
+
+$LOAD_PATH.unshift File.expand_path("#{File.dirname(__FILE__)}/../lib")
+require "rr"
+require "pp"

data/spec/minitest_spec_suite.rb

@@ -0,0 +1,21 @@
+require "rubygems"
+require "spec"
+
+class MiniTestTestSuite
+  def run
+    require_tests
+
+    puts "Running MiniTest Test Suite"
+  end
+
+  def require_tests
+    dir = File.dirname(__FILE__)
+    Dir["#{dir}/rr/minitest/**/*_test.rb"].each do |file|
+      require File.expand_path(file)
+    end
+  end
+end
+
+if $0 == __FILE__
+  MiniTestTestSuite.new.run
+end

data/spec/proc_from_block_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path("#{File.dirname(__FILE__)}/spec_helper")
+
+module RR
+  describe ProcFromBlock do
+    describe "#==" do
+      it "acts the same as #== on a Proc" do
+        original_proc = lambda {}
+        Proc.new(&original_proc).should == original_proc
+        
+        ProcFromBlock.new(&original_proc).should == original_proc
+      end
+    end
+  end
+end

data/spec/rr/adapters/rr_methods_argument_matcher_spec.rb

@@ -0,0 +1,67 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module Adapters
+    describe RRMethods do
+      describe "#anything" do
+        it_should_behave_like "RR::Adapters::RRMethods"
+
+        it "returns an Anything matcher" do
+          anything.should == RR::WildcardMatchers::Anything.new
+        end
+
+        it "rr_anything returns an Anything matcher" do
+          rr_anything.should == RR::WildcardMatchers::Anything.new
+        end
+      end
+
+      describe "#is_a" do
+        it_should_behave_like "RR::Adapters::RRMethods"
+
+        it "returns an IsA matcher" do
+          is_a(Integer).should == RR::WildcardMatchers::IsA.new(Integer)
+        end
+
+        it "rr_is_a returns an IsA matcher" do
+          rr_is_a(Integer).should == RR::WildcardMatchers::IsA.new(Integer)
+        end
+      end
+
+      describe "#numeric" do
+        it_should_behave_like "RR::Adapters::RRMethods"
+
+        it "returns an Numeric matcher" do
+          numeric.should == RR::WildcardMatchers::Numeric.new
+        end
+
+        it "rr_numeric returns an Numeric matcher" do
+          rr_numeric.should == RR::WildcardMatchers::Numeric.new
+        end
+      end
+
+      describe "#boolean" do
+        it_should_behave_like "RR::Adapters::RRMethods"
+
+        it "returns an Boolean matcher" do
+          boolean.should == RR::WildcardMatchers::Boolean.new
+        end
+
+        it "rr_boolean returns an Boolean matcher" do
+          rr_boolean.should == RR::WildcardMatchers::Boolean.new
+        end
+      end
+
+      describe "#duck_type" do
+        it_should_behave_like "RR::Adapters::RRMethods"
+
+        it "returns a DuckType matcher" do
+          duck_type(:one, :two).should == RR::WildcardMatchers::DuckType.new(:one, :two)
+        end
+
+        it "rr_duck_type returns a DuckType matcher" do
+          rr_duck_type(:one, :two).should == RR::WildcardMatchers::DuckType.new(:one, :two)
+        end
+      end
+    end
+  end
+end

data/spec/rr/adapters/rr_methods_creator_spec.rb

@@ -0,0 +1,137 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module Adapters
+    describe RRMethods do
+      attr_reader :subject
+      before(:each) do
+        @subject = Object.new
+      end
+
+      after(:each) do
+        RR.reset
+      end
+
+      describe "normal strategy definitions" do
+        attr_reader :strategy_method_name
+        def call_strategy(*args, &block)
+          __send__(strategy_method_name, *args, &block)
+        end
+
+        describe "#mock" do
+          before do
+            @strategy_method_name = :mock
+          end
+
+          context "when passing no args" do
+            it "returns a DoubleDefinitionCreate" do
+              call_strategy.class.should == RR::DoubleDefinitions::DoubleDefinitionCreate
+            end
+          end
+
+          context "when passed a method_name argument" do
+            it "creates a mock Double for method" do
+              double_definition = mock(subject, :foobar).returns {:baz}
+              double_definition.times_matcher.should == RR::TimesCalledMatchers::IntegerMatcher.new(1)
+              double_definition.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+              double_definition.argument_expectation.expected_arguments.should == []
+              subject.foobar.should == :baz
+            end
+          end
+        end
+
+        describe "#stub" do
+          before do
+            @strategy_method_name = :stub
+          end
+
+          context "when passing no args" do
+            it "returns a DoubleDefinitionCreate" do
+              call_strategy.class.should == RR::DoubleDefinitions::DoubleDefinitionCreate
+            end
+          end
+
+          context "when passed a method_name argument" do
+            it "creates a stub Double for method when passed a method_name argument" do
+              double_definition = stub(subject, :foobar).returns {:baz}
+              double_definition.times_matcher.should == RR::TimesCalledMatchers::AnyTimesMatcher.new
+              double_definition.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
+              subject.foobar.should == :baz
+            end
+          end
+        end
+
+        describe "#dont_allow" do
+          before do
+            @strategy_method_name = :dont_allow
+          end
+
+          context "when passing no args" do
+            it "returns a DoubleDefinitionCreate" do
+              call_strategy.class.should == RR::DoubleDefinitions::DoubleDefinitionCreate
+            end
+          end
+
+          context "when passed a method_name argument_expectation" do
+            it "creates a mock Double for method" do
+              double_definition = dont_allow(subject, :foobar)
+              double_definition.times_matcher.should == RR::TimesCalledMatchers::NeverMatcher.new
+              double_definition.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
+
+              lambda do
+                subject.foobar
+              end.should raise_error(RR::Errors::TimesCalledError)
+              RR.reset
+            end
+          end
+        end
+      end
+
+      describe "! strategy definitions" do
+        attr_reader :strategy_method_name
+        def call_strategy(*args, &definition_eval_block)
+          __send__(strategy_method_name, *args, &definition_eval_block)
+        end
+
+        describe "#mock!" do
+          before do
+            @strategy_method_name = :mock!
+          end
+
+          context "when passed a method_name argument" do
+            it "sets #verification_strategy to Mock" do
+              proxy = mock!(:foobar)
+              proxy.double_definition_create.verification_strategy.class.should == RR::DoubleDefinitions::Strategies::Verification::Mock
+            end
+          end
+        end
+
+        describe "#stub!" do
+          before do
+            @strategy_method_name = :stub!
+          end
+
+          context "when passed a method_name argument" do
+            it "sets #verification_strategy to Stub" do
+              proxy = stub!(:foobar)
+              proxy.double_definition_create.verification_strategy.class.should == RR::DoubleDefinitions::Strategies::Verification::Stub
+            end
+          end
+        end
+
+        describe "#dont_allow!" do
+          before do
+            @strategy_method_name = :dont_allow!
+          end
+
+          context "when passed a method_name argument" do
+            it "sets #verification_strategy to DontAllow" do
+              proxy = dont_allow!(:foobar)
+              proxy.double_definition_create.verification_strategy.class.should == RR::DoubleDefinitions::Strategies::Verification::DontAllow
+            end
+          end
+        end
+      end
+    end
+  end
+end