rr 1.1.1.rc1 → 1.1.1

data/spec/suites/rspec_2/unit/injections/double_injection/double_injection_verify_spec.rb

@@ -1,32 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../../spec_helper")
-
-module RR
-  module Injections
-    describe DoubleInjection, "#verify" do
-      subject { Object.new }
-
-      include_examples "Swapped Space"
-
-      attr_reader :method_name, :double_injection
-
-      before do
-        @method_name = :foobar
-        subject.methods.should_not include(method_name.to_s)
-        @double_injection = ::RR::Injections::DoubleInjection.find_or_create_by_subject(subject, method_name)
-      end
-
-      it "verifies each double was met" do
-        double = RR::Double.new(
-          double_injection,
-          RR::DoubleDefinitions::DoubleDefinition.new(RR::DoubleDefinitions::DoubleDefinitionCreate.new)
-        )
-        double_injection.register_double double
-
-        double.definition.with(1).once.returns {nil}
-        expect { double_injection.verify }.to raise_error(RR::Errors::TimesCalledError)
-        subject.foobar(1)
-        expect { double_injection.verify }.to_not raise_error
-      end
-    end
-  end
-end

data/spec/suites/rspec_2/unit/integrations/rspec/invocation_matcher_spec.rb

@@ -1,297 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../../spec_helper")
-
-module RR
-  module Integrations
-    module RSpec
-      describe InvocationMatcher do
-        describe "matching against a method with no doubles" do
-          before do
-            @matcher = InvocationMatcher.new(:foobar)
-            @result = @matcher.matches?(Object.new)
-          end
-
-          it "does not match" do
-            @result.should_not be
-          end
-        end
-
-        describe "defining an expectation using a method invocation" do
-          subject { Object.new }
-
-          before do
-            stub(subject).foobar
-            subject.foobar(:args)
-            @result = InvocationMatcher.new.foobar(:args).matches?(subject)
-          end
-
-          it "uses the invoked method as the expected method" do
-            expect(@result).to be
-          end
-        end
-
-        describe "matching against a stubbed method that was never called" do
-          subject { Object.new }
-
-          before do
-            stub(subject).foobar
-            @matcher = InvocationMatcher.new(:foobar)
-            @result = @matcher.matches?(subject)
-          end
-
-          it "does not match" do
-            @result.should_not be
-          end
-        end
-
-        describe "matching against a stubbed method that was called once" do
-          subject { Object.new }
-
-          before do
-            stub(subject).foobar
-            subject.foobar
-            @result = InvocationMatcher.new(:foobar).matches?(subject)
-          end
-
-          it "does match" do
-            expect(@result).to be
-          end
-        end
-
-        describe "matching against a stubbed method that was called with unexpected arguments" do
-          subject { Object.new }
-
-          before do
-            @args = %w(one two)
-            stub(subject).foobar
-            subject.foobar(:other)
-            @result = InvocationMatcher.new(:foobar).with(*@args).matches?(subject)
-          end
-
-          it "does not match" do
-            @result.should_not be
-          end
-        end
-
-        describe "matching against a stubbed method that was called with expected arguments" do
-          subject { Object.new }
-
-          before do
-            @args = %w(one two)
-            stub(subject).foobar
-            subject.foobar(*@args)
-            @result = InvocationMatcher.new(:foobar).with(*@args).matches?(subject)
-          end
-
-          it "does match" do
-            expect(@result).to be
-          end
-        end
-
-        describe "defining a fulfilled argument expectation using a method invocation" do
-          subject { Object.new }
-
-          before do
-            @args = %w(one two)
-            stub(subject).foobar
-            subject.foobar(*@args)
-            @result = InvocationMatcher.new.foobar(*@args).matches?(subject)
-          end
-
-          it "does match" do
-            expect(@result).to be
-          end
-        end
-
-        describe "defining an unfulfilled argument expectation using a method invocation" do
-          subject { Object.new }
-
-          before do
-            @args = %w(one two)
-            stub(subject).foobar
-            subject.foobar(:other)
-            @result = InvocationMatcher.new.foobar(*@args).matches?(subject)
-          end
-
-          it "does not match" do
-            @result.should_not be
-          end
-        end
-
-        describe "matching against a stubbed method that was called more than once" do
-          subject { Object.new }
-
-          before do
-            stub(subject).foobar
-            2.times { subject.foobar }
-            @result = InvocationMatcher.new(:foobar).twice.matches?(subject)
-          end
-
-          it "does match" do
-            expect(@result).to be
-          end
-        end
-
-        describe "matching a stubbed method with any arguments" do
-          subject { Object.new }
-
-          before do
-            stub(subject).foobar
-            subject.foobar(:args)
-            @result = InvocationMatcher.new(:foobar).with_any_args.matches?(subject)
-          end
-
-          it "does match" do
-            expect(@result).to be
-          end
-        end
-
-        describe "matching a stubbed method with no arguments when arguments are not provided" do
-          subject { Object.new }
-
-          before do
-            stub(subject).foobar
-            subject.foobar
-            @result = InvocationMatcher.new(:foobar).with_no_args.matches?(subject)
-          end
-
-          it "does match" do
-            expect(@result).to be
-          end
-        end
-
-        describe "matching a stubbed method with no arguments when arguments are provided" do
-          subject { Object.new }
-
-          before do
-            stub(subject).foobar
-            subject.foobar(:args)
-            @result = InvocationMatcher.new(:foobar).with_no_args.matches?(subject)
-          end
-
-          it "does not match" do
-            @result.should_not be
-          end
-        end
-
-        describe "matching a method that was called twice when expected once" do
-          subject { Object.new }
-
-          before do
-            stub(subject).foobar
-            2.times { subject.foobar }
-            @matcher = InvocationMatcher.new(:foobar).times(1)
-            @result = @matcher.matches?(subject)
-          end
-
-          it "does not match" do
-            @result.should_not be
-          end
-        end
-
-        describe "matching a method that was called twice when expected twice" do
-          subject { Object.new }
-
-          before do
-            stub(subject).foobar
-            2.times { subject.foobar }
-            @result = InvocationMatcher.new(:foobar).times(2).matches?(subject)
-          end
-
-          it "does match" do
-            expect(@result).to be
-          end
-        end
-
-        describe "matching a method that was called twice when any number of times" do
-          subject { Object.new }
-
-          before do
-            stub(subject).foobar
-            2.times { subject.foobar }
-            @result = InvocationMatcher.new(:foobar).any_number_of_times.matches?(subject)
-          end
-
-          it "does match" do
-            expect(@result).to be
-          end
-        end
-
-        describe "matching a method that was called three times when expected at most twice" do
-          subject { Object.new }
-
-          before do
-            stub(subject).foobar
-            3.times { subject.foobar }
-            @result = InvocationMatcher.new(:foobar).at_most(2).matches?(subject)
-          end
-
-          it "does not match" do
-            @result.should_not be
-          end
-        end
-
-        describe "matching a method that was called once when expected at most twice" do
-          subject { Object.new }
-
-          before do
-            stub(subject).foobar
-            subject.foobar
-            @result = InvocationMatcher.new(:foobar).at_most(2).matches?(subject)
-          end
-
-          it "does match" do
-            expect(@result).to be
-          end
-        end
-
-        describe "matching a method that was called once when expected at least twice" do
-          subject { Object.new }
-
-          before do
-            stub(subject).foobar
-            subject.foobar
-            @result = InvocationMatcher.new(:foobar).at_least(2).matches?(subject)
-          end
-
-          it "does not match" do
-            @result.should_not be
-          end
-        end
-
-        describe "matching a method that was called three times when expected at least twice" do
-          subject { Object.new }
-
-          before do
-            stub(subject).foobar
-            3.times { subject.foobar }
-            @result = InvocationMatcher.new(:foobar).at_least(2).matches?(subject)
-          end
-
-          it "does match" do
-            expect(@result).to be
-          end
-        end
-
-        describe "that does not match" do
-          before do
-            @error = Object.new
-            @message = 'Verification error message'
-            stub(RR::Space.instance.recorded_calls).match_error { @error }
-            stub(@error).message { @message }
-
-            @matcher = InvocationMatcher.new(:foobar)
-            @result = @matcher.matches?(Object.new)
-          end
-
-          it "returns false when matching" do
-            @result.should_not be
-          end
-
-          it "returns a failure messsage" do
-            expect(@matcher.failure_message).to eq @message
-          end
-        end
-      end
-    end
-  end
-end

data/spec/suites/rspec_2/unit/integrations/rspec_spec.rb

@@ -1,85 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
-
-module RR
-  module Integrations
-    describe RSpec1 do
-      attr_reader :fixture, :method_name
-
-      describe "#setup_mocks_for_rspec" do
-        subject { Object.new }
-
-        before do
-          @fixture = Object.new
-          fixture.extend RSpec1::Mixin
-          @method_name = :foobar
-        end
-
-        it "resets the double_injections" do
-          stub(subject).foobar
-          ::RR::Injections::DoubleInjection.instances.should_not be_empty
-
-          fixture.setup_mocks_for_rspec
-          expect(::RR::Injections::DoubleInjection.instances).to be_empty
-        end
-      end
-
-      describe "#verify_mocks_for_rspec" do
-        subject { Object.new }
-
-        before do
-          @fixture = Object.new
-          fixture.extend RSpec1::Mixin
-          @method_name = :foobar
-        end
-
-        it "verifies the double_injections" do
-          mock(subject).foobar
-
-          expect {
-            fixture.verify_mocks_for_rspec
-          }.to raise_error(::RR::Errors::TimesCalledError)
-          expect(::RR::Injections::DoubleInjection.instances).to be_empty
-        end
-      end
-
-      describe "#teardown_mocks_for_rspec" do
-        subject { Object.new }
-
-        before do
-          @fixture = Object.new
-          fixture.extend RSpec1::Mixin
-          @method_name = :foobar
-        end
-
-        it "resets the double_injections" do
-          stub(subject).foobar
-          ::RR::Injections::DoubleInjection.instances.should_not be_empty
-
-          fixture.teardown_mocks_for_rspec
-          expect(::RR::Injections::DoubleInjection.instances).to be_empty
-        end
-      end
-
-      describe "#trim_backtrace" do
-        it "does not set trim_backtrace" do
-          expect(RR.trim_backtrace).to eq false
-        end
-      end
-
-      describe '#have_received' do
-        it "creates an invocation matcher with a method name" do
-          method  = :test
-          matcher = 'fake'
-          mock(RR::Integrations::RSpec::InvocationMatcher).new(method) { matcher }
-          expect(have_received(method)).to eq matcher
-        end
-
-        it "creates an invocation matcher without a method name" do
-          matcher = 'fake'
-          mock(RR::Integrations::RSpec::InvocationMatcher).new(nil) { matcher }
-          expect(have_received).to eq matcher
-        end
-      end
-    end
-  end
-end

data/spec/suites/rspec_2/unit/proc_from_block_spec.rb

@@ -1,14 +0,0 @@
-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 {}
-        expect(Proc.new(&original_proc)).to eq original_proc
-
-        expect(ProcFromBlock.new(&original_proc)).to eq original_proc
-      end
-    end
-  end
-end

data/spec/suites/rspec_2/unit/rr_spec.rb

@@ -1,28 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
-
-describe "RR" do
-  before do
-    Object.class_eval do
-      def verify
-        raise "Dont call me"
-      end
-    end
-  end
-
-  after do
-    Object.class_eval do
-      remove_method :verify
-    end
-  end
-
-  it "has proxy methods for each method defined directly on Space" do
-    space_instance_methods = RR::Space.instance_methods(false)
-    space_instance_methods.should_not be_empty
-
-    rr_instance_methods = RR.methods(false)
-    space_instance_methods.each do |space_instance_method|
-      expect(rr_instance_methods).to include(space_instance_method)
-    end
-    RR.verify
-  end
-end