rspec_candy 0.1.0

data/spec/shared/rspec_candy/helpers/rails/create_without_callbacks_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe RSpecCandy::Helpers::Rails::CreateWithoutCallbacks do
+
+  describe ActiveRecord::Base do
+
+    describe '.create_without_callbacks' do
+
+      it 'should create a record without running callbacks or validations' do
+        model = Model.disposable_copy do
+          before_save :crash
+          validate :crash
+          def crash
+            raise 'callback was run'
+          end
+        end
+        record = nil
+        expect do
+          record = model.create_without_callbacks(:string_field => 'foo')
+        end.to_not raise_error
+        record.string_field.should == 'foo'
+        record.should be_a(Model)
+        record.id.should be_a(Fixnum)
+        record.should_not be_new_record
+      end
+
+    end
+
+    describe '.new_and_store' do
+
+      it 'should print a deprecation warning urging to use .create_without_callbacks instead' do
+        Model.should_receive(:warn).with(/Use create_without_callbacks instead/i)
+        Model.should_receive(:create_without_callbacks).with('args')
+        Model.new_and_store('args')
+      end
+
+    end
+
+  end
+
+end

data/spec/shared/rspec_candy/helpers/rails/it_should_run_callbacks_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe RSpecCandy::Helpers::Rails::ItShouldRunCallbacks do
+
+  describe '#it_should_run_callbacks' do
+
+    context 'for an app without state_machine' do
+
+      it 'should pass if all callbacks have been run' do
+        <<-describe_block.should pass_as_describe_block
+          describe Model, '#after_save' do
+            it_should_run_callbacks :after_save_callback2, :after_save_callback1
+          end
+        describe_block
+      end
+
+      it 'should only attempt to run the proper callbacks have been run' do
+        <<-describe_block.should fail_as_describe_block
+          describe Model, '#before_save' do
+            it_should_run_callbacks :after_save_callback2, :after_save_callback1
+          end
+        describe_block
+      end
+
+      it 'should not pass if a callback has not been run' do
+        <<-describe_block.should fail_as_describe_block
+          describe Model, '#after_create' do
+            it_should_run_callbacks :after_create_callback, :unknown_callback
+          end
+        describe_block
+      end
+
+      it 'should not actually execute the callbacks' do
+        <<-describe_block.should pass_as_describe_block
+          def Model.after_save_callback2
+            raise "called!"
+          end
+
+          describe Model, '#after_save' do
+            it_should_run_callbacks :after_save_callback1
+          end
+        describe_block
+      end
+
+      it 'should not parse state_machine callbacks being present' do
+        <<-describe_block.should fail_as_describe_block
+          describe StateMachineModel, '#event from :state1 to :state2' do
+            it_should_run_callbacks :event_callback
+          end
+        describe_block
+      end
+
+    end
+
+    context 'for an app with state_machine' do
+
+      before do
+        ENV['REQUIRE_STATE_MACHINE'] = 'true'
+      end
+
+      after do
+        ENV['REQUIRE_STATE_MACHINE'] = 'false'
+      end
+
+      it 'should pass if all callbacks have been run' do
+        <<-describe_block.should pass_as_describe_block
+          describe Model, '#after_save' do
+            it_should_run_callbacks :after_save_callback2, :after_save_callback1
+          end
+        describe_block
+      end
+
+      it 'should not pass if a callback has not been run' do
+        <<-describe_block.should fail_as_describe_block
+          describe Model, '#after_create' do
+            it_should_run_callbacks :after_create_callback, :unknown_callback
+          end
+        describe_block
+      end
+
+
+      it 'should also run state machine callbacks and pass if they are called if StateMachine is present' do
+        <<-describe_block.should pass_as_describe_block
+          describe StateMachineModel, '#event from :state1 to :state2' do
+            it_should_run_callbacks :event_callback
+          end
+        describe_block
+      end
+
+      it 'should also run state machine callbacks and fail if they are not called if StateMachine is present' do
+        <<-describe_block.should fail_as_describe_block
+          describe StateMachineModel, '#event from :state1 to :state3' do
+            it_should_run_callbacks :event_callback
+          end
+        describe_block
+      end
+
+    end
+
+
+  end
+
+  describe '#it_should_run_callbacks_in_order' do
+
+    supported_callbacks = case RSpecCandy::Switcher.rspec_version
+    when :rspec1
+      %w[before after]
+    when :rspec2
+      %w[before after around]
+    end
+
+    supported_callbacks.each do |kind|
+
+      it "should pass if all #{kind} callbacks are run in order" do
+        <<-describe_block.should pass_as_describe_block
+          describe Model, '##{kind}_save' do
+            it_should_run_callbacks_in_order :#{kind}_save_callback1, :#{kind}_save_callback2
+          end
+        describe_block
+      end
+
+      it "should not pass if a #{kind} callback has not been run" do
+        <<-describe_block.should fail_as_describe_block
+          describe Model, '##{kind}_create' do
+            it_should_run_callbacks_in_order :#{kind}_create_callback, :unknown_callback
+          end
+        describe_block
+      end
+
+      it "should not pass if #{kind} callbacks are run out of order" do
+        <<-describe_block.should fail_as_describe_block
+          describe Model, '##{kind}_save' do
+            it_should_run_callbacks_in_order :#{kind}_save_callback2, :#{kind}_save_callback1
+          end
+        describe_block
+      end
+
+    end
+
+  end
+
+end

data/spec/shared/rspec_candy/helpers/rails/prevent_storage_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe RSpecCandy::Helpers::Rails::PreventStorage do
+
+  describe ActiveRecord::Base do
+
+    describe '#prevent_storage' do
+
+      context 'when attempting to save the record afterwards' do
+
+        it 'should run validations' do
+          klass = Model.disposable_copy do
+            validate :validation_method
+          end
+          record = klass.new
+          record.prevent_storage
+          record.should_receive :validation_method
+          record.save
+        end
+
+        it 'should run before_validate callbacks' do
+          klass = Model.disposable_copy do
+            before_validation :callback_method
+          end
+          record = klass.new
+          record.prevent_storage
+          record.should_receive :callback_method
+          record.save
+        end
+
+        it 'should run after_validate callbacks' do
+          klass = Model.disposable_copy do
+            after_validation :callback_method
+          end
+          record = klass.new
+          record.prevent_storage
+          record.should_receive :callback_method
+          record.save
+        end
+
+        it 'should prevent the record from being committed to the database' do
+          record = Model.new
+          record.prevent_storage
+          record.save.should be_false
+          Model.count.should be_zero
+        end
+
+        it 'should not run before_save callbacks' do
+          klass = Model.disposable_copy do
+            before_save :callback_method
+          end
+          record = klass.new
+          record.prevent_storage
+          record.should_not_receive :callback_method
+          record.save
+        end
+
+        it 'should not run after_save callbacks' do
+          klass = Model.disposable_copy do
+            after_save :callback_method
+          end
+          record = klass.new
+          record.prevent_storage
+          record.should_not_receive :callback_method
+          record.save
+        end
+
+      end
+
+    end
+
+    describe '#keep_invalid!' do
+
+      it 'should print a deprecation warning asking to use #prevent_storage' do
+        record = Model.new
+        record.should_receive(:warn).with(/Use prevent_storage instead/i)
+        record.should_receive(:prevent_storage)
+        record.keep_invalid!
+      end
+
+    end
+
+  end
+
+end

data/spec/shared/rspec_candy/helpers/should_receive_and_execute_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe RSpecCandy::Helpers::ShouldReceiveAndExecute do
+
+  describe Object do
+
+    describe '#should_receive_and_execute' do
+
+      it 'should not stub away the original method implementation' do
+        object = "object"
+        object.should_receive_and_execute(:size)
+        object.size.should == 6
+      end
+
+      it 'should set an expectation that the given method are called' do
+        (<<-example).should fail_as_example
+          object = 'object'
+          object.should_receive_and_execute(:size)
+        example
+      end
+
+      it 'should return the expectation for further parameterization' do
+        object = 'object'
+        object.should_receive_and_execute(:size).class.name.should include('MessageExpectation')
+        object.size # make the example pass
+      end
+
+    end
+
+  end
+
+end

data/spec/shared/rspec_candy/helpers/should_receive_and_return_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe RSpecCandy::Helpers::StubExisting do
+
+  describe Object do
+
+    describe '#should_receive_and_return' do
+
+      it 'should stub out the given methods with the given return values' do
+        object = 'object'
+        object.should_receive_and_return(:foo => 'foo', :bar => 'bar')
+        object.foo.should == 'foo'
+        object.bar.should == 'bar'
+        object.size.should == 6 # object still responds to unstubbed methods
+      end
+
+      it 'should set expectations that all given methods are called' do
+        (<<-example).should fail_as_example
+          object = 'object'
+          object.should_receive_and_return(:foo => 'foo', :bar => 'bar')
+          object.foo
+          # but not object.bar
+        example
+      end
+
+    end
+
+  end
+
+end

data/spec/shared/rspec_candy/helpers/should_receive_chain_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe RSpecCandy::Helpers::ShouldReceiveChain do
+
+  describe Object do
+
+    describe '#should_receive_chain' do
+
+      it "should pass when the chain was traversed completely" do
+        (<<-example).should pass_as_example
+          object = "object"
+          object.should_receive_chain(:first_message, :second_message)
+          object.first_message.second_message
+        example
+      end
+
+      it "should fail when the chain wasn't traversed at all" do
+        (<<-example).should fail_as_example
+          object = "object"
+          object.should_receive_chain(:first_message, :second_message)
+        example
+      end
+
+      it "should fail when the chain was only traversed partially" do
+        (<<-example).should fail_as_example
+          object = "object"
+          object.should_receive_chain(:first_message, :second_message)
+          object.first_message
+        example
+      end
+
+      it "should allow to add argument expectations to inner chain links by using array notation" do
+        (<<-example).should pass_as_example
+          object = "object"
+          object.should_receive_chain([:first_message, 'argument'], :second_message)
+          object.first_message('argument').second_message
+        example
+        (<<-example).should fail_as_example
+          object = "object"
+          object.should_receive_chain([:first_message, 'argument'], :second_message)
+          object.first_message('wrong argument').second_message
+        example
+      end
+
+      it "should allow to add argument expectations to the last chain link by using regular should_receive options" do
+        (<<-example).should pass_as_example
+          object = "object"
+          object.should_receive_chain(:first_message, :second_message).with('argument')
+          object.first_message.second_message('argument')
+        example
+        (<<-example).should fail_as_example
+          object = "object"
+          object.should_receive_chain(:first_message, :second_message).with('argument')
+          object.first_message.second_message('wrong argument')
+        example
+      end
+
+      it 'should allow inner chain links to be called more than once' do
+        (<<-example).should pass_as_example
+          object = "object"
+          object.should_receive_chain(:first_message, :second_message)
+          object.first_message
+          object.first_message.second_message
+        example
+      end
+
+    end
+
+
+    describe '#should_not_receive_chain' do
+
+      it "should fail when the chain was traversed completely" do
+        (<<-example).should fail_as_example
+          object = "object"
+          object.should_not_receive_chain(:first_message, :second_message)
+          object.first_message.second_message
+        example
+      end
+
+      it "should pass when the chain wasn't traversed at all" do
+        (<<-example).should pass_as_example
+          object = "object"
+          object.should_not_receive_chain(:first_message, :second_message)
+        example
+      end
+
+      it "should pass when the chain was only traversed partially" do
+        (<<-example).should pass_as_example
+          object = "object"
+          object.should_not_receive_chain(:first_message, :second_message)
+          object.first_message
+        example
+      end
+
+    end
+
+  end
+
+end

data/spec/shared/rspec_candy/helpers/stub_any_instance_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe RSpecCandy::Helpers::StubAnyInstance do
+
+  describe Class do
+
+    describe '#stub_any_instance' do
+
+      it 'should apply the given stubs to all future instances of that class' do
+        klass = Class.new {}
+        klass.stub_any_instance(:stubbed_method => 'result')
+        2.times do
+          klass.new.stubbed_method.should == 'result'
+        end
+      end
+
+      it 'should not prevent initializer code to be run' do
+        klass = Class.new do
+          attr_reader :initializer_run
+          def initialize
+            @initializer_run = true
+          end
+        end
+        klass.stub_any_instance(:stubbed_method => 'result')
+        klass.new.initializer_run.should == true
+      end
+
+    end
+
+  end
+
+end