rspec 0.8.2 → 0.9.0

data/spec/spec/dsl/predicate_matcher_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Spec
+  module DSL
+    class Fish
+      def can_swim?(distance_in_yards)
+        distance_in_yards < 1000
+      end
+    end
+    
+    describe "predicate_matcher[method_on_object] = matcher_method" do
+      predicate_matchers[:can_swim?] = :swim
+      it "should match matcher_method if method_on_object returns true" do
+        swim(100).matches?(Fish.new).should be_true
+      end
+      it "should not match matcher_method if method_on_object returns false" do
+        swim(10000).matches?(Fish.new).should be_false
+      end
+    end
+  end
+end

data/spec/spec/dsl/shared_behaviour_spec.rb

@@ -0,0 +1,186 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Spec
+  module DSL
+    describe Behaviour, ", with :shared => true" do
+      
+      before do
+        @formatter = Spec::Mocks::Mock.new("formatter", :null_object => true)
+        @behaviour = behaviour_class.new("context") {}
+      end
+
+      after do
+        @formatter.rspec_verify
+        @behaviour_class = nil
+        $shared_behaviours.clear unless $shared_behaviours.nil?
+      end
+
+      def behaviour_class
+        unless @behaviour_class
+          @behaviour_class = Behaviour.dup
+          # dup copies the class instance vars
+          @behaviour_class.instance_variable_set(:@shared_behaviours, nil)
+        end
+        @behaviour_class
+      end
+
+      def make_shared_behaviour(name, opts, &block)
+        behaviour = behaviour_class.new(name, opts, &block)
+        behaviour_class.add_shared_behaviour(behaviour)
+        behaviour
+      end
+
+      it "should accept an optional options hash" do
+        lambda { behaviour_class.new("context") {} }.should_not raise_error(Exception)
+        lambda { behaviour_class.new("context", :shared => true) {} }.should_not raise_error(Exception)
+      end
+
+      it "should return all shared behaviours" do
+        make_shared_behaviour("b1", :shared => true) {}
+        make_shared_behaviour("b2", :shared => true) {}
+        
+        behaviour_class.find_shared_behaviour("b1").should_not be_nil
+        behaviour_class.find_shared_behaviour("b2").should_not be_nil
+      end
+
+      it "should be shared when configured as shared" do
+        behaviour = make_shared_behaviour("context", :shared => true) {}
+        behaviour.should be_shared
+      end
+
+      it "should not be shared when not configured as shared" do
+        @behaviour.should_not be_shared
+      end
+
+      it "should not run when shared" do
+        behaviour = make_shared_behaviour("context", :shared => true) {}
+        $spec_ran = false
+        behaviour.it("test") {$spec_ran = true}
+        behaviour.run(@formatter)
+        $spec_ran.should be_false
+      end
+
+      it "should contain examples when shared" do
+        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
+        shared_behaviour.it("shared example") {}
+        shared_behaviour.number_of_examples.should == 1
+      end
+
+      it "should complain when adding a shared behaviour with the same description" do
+        make_shared_behaviour("shared behaviour", :shared => true) {}
+        lambda { make_shared_behaviour("shared behaviour", :shared => true) {} }.should raise_error(ArgumentError)
+      end
+
+      it "should add examples to current behaviour when calling it_should_behave_like" do
+        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
+        shared_behaviour.it("shared example") {}
+        shared_behaviour.it("shared example 2") {}
+
+        @behaviour.it("example") {}
+        @behaviour.number_of_examples.should == 1
+        @behaviour.it_should_behave_like("shared behaviour")
+        @behaviour.number_of_examples.should == 3
+      end
+
+      it "should run shared examples" do
+        shared_example_ran = false
+        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
+        shared_behaviour.it("shared example") { shared_example_ran = true }
+
+        example_ran = false
+
+        @behaviour.it_should_behave_like("shared behaviour")
+        @behaviour.it("example") {example_ran = true}
+        @behaviour.run(@formatter)
+        example_ran.should be_true
+        shared_example_ran.should be_true
+      end
+
+      it "should run setup and teardown from shared behaviour" do
+        shared_setup_ran = false
+        shared_teardown_ran = false
+        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
+        shared_behaviour.before { shared_setup_ran = true }
+        shared_behaviour.after { shared_teardown_ran = true }
+        shared_behaviour.it("shared example") { shared_example_ran = true }
+
+        example_ran = false
+
+        @behaviour.it_should_behave_like("shared behaviour")
+        @behaviour.it("example") {example_ran = true}
+        @behaviour.run(@formatter)
+        example_ran.should be_true
+        shared_setup_ran.should be_true
+        shared_teardown_ran.should be_true
+      end
+
+      it "should run before(:all) and after(:all) only once from shared behaviour" do
+        shared_before_all_run_count = 0
+        shared_after_all_run_count = 0
+        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
+        shared_behaviour.before(:all) { shared_before_all_run_count += 1}
+        shared_behaviour.after(:all) { shared_after_all_run_count += 1}
+        shared_behaviour.it("shared example") { shared_example_ran = true }
+
+        example_ran = false
+
+        @behaviour.it_should_behave_like("shared behaviour")
+        @behaviour.it("example") {example_ran = true}
+        @behaviour.run(@formatter)
+        example_ran.should be_true
+        shared_before_all_run_count.should == 1
+        shared_after_all_run_count.should == 1
+      end
+
+      it "should include modules, included into shared behaviour, into current behaviour" do
+        @formatter.should_receive(:add_behaviour).with :any_args
+        @formatter.should_receive(:example_finished).twice.with :any_args
+
+        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
+        shared_behaviour.it("shared example") { shared_example_ran = true }
+
+        mod1_method_called = false
+        mod1 = Module.new do
+          define_method :mod1_method do
+            mod1_method_called = true
+          end
+        end
+
+        mod2_method_called = false
+        mod2 = Module.new do
+          define_method :mod2_method do
+            mod2_method_called = true
+          end
+        end
+
+        shared_behaviour.include mod2
+
+        @behaviour.it_should_behave_like("shared behaviour")
+        @behaviour.include mod1
+
+        @behaviour.it("test") do
+          mod1_method
+          mod2_method
+        end
+        @behaviour.run(@formatter)
+        mod1_method_called.should be_true
+        mod2_method_called.should be_true
+      end
+
+      it "should error if told to inherit from a class" do
+        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
+        shared_behaviour.it("shared example") { shared_example_ran = true }
+        lambda { shared_behaviour.inherit Object }.should raise_error(ArgumentError)
+      end
+      
+      it "should raise when named shared behaviour can not be found" do
+        begin
+          @behaviour.it_should_behave_like("non-existent shared behaviour")
+          violated
+        rescue => e
+          e.message.should == "Shared Behaviour 'non-existent shared behaviour' can not be found"
+        end
+      end
+    end
+  end
+end

data/spec/spec/expectations/differs/default_spec.rb

@@ -20,20 +20,20 @@ module Spec
   end
 end
 
-context "Diff" do
-  setup do
+describe "Diff" do
+  before(:each) do
     @differ = Spec::Expectations::Differs::Default.new
   end
 
-  specify "should output unified diff of two strings" do
+  it "should output unified diff of two strings" do
     expected="foo\nbar\nzap\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nline\n"
     actual="foo\nzap\nbar\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nanother\nline\n"
     expected_diff="\n\n@@ -1,6 +1,6 @@\n foo\n-bar\n zap\n+bar\n this\n is\n soo\n@@ -9,5 +9,6 @@\n equal\n insert\n a\n+another\n line\n"
     diff = @differ.diff_as_string(expected, actual)
-    diff.should_eql(expected_diff)
+    diff.should eql(expected_diff)
   end
 
-  specify "should output unified diff message of two arrays" do
+  it "should output unified diff message of two arrays" do
     expected = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'charlie', :width, 'quite wide' ]
     actual   = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'tango'  , :width, 'very wide'  ]
 
@@ -53,10 +53,10 @@ EOD
 
 
     diff = @differ.diff_as_object(expected,actual)
-    diff.should_eql expected_diff
+    diff.should == expected_diff
   end
 
-  specify "should output unified diff message of two objects" do
+  it "should output unified diff message of two objects" do
     expected = Spec::Fixtures::Animal.new "bob", "giraffe"
     actual   = Spec::Fixtures::Animal.new "bob", "tortoise"
 
@@ -71,18 +71,18 @@ EOD
 EOD
 
     diff = @differ.diff_as_object(expected,actual)
-    diff.should_eql expected_diff
+    diff.should == expected_diff
   end
 
 end
 
 
-context "Diff in context format" do
-  setup do
+describe "Diff in context format" do
+  before(:each) do
     @differ = Spec::Expectations::Differs::Default.new(:context)
   end
 
-  specify "should output unified diff message of two objects" do
+  it "should output unified diff message of two objects" do
     expected = Spec::Fixtures::Animal.new "bob", "giraffe"
     actual   = Spec::Fixtures::Animal.new "bob", "tortoise"
 
@@ -102,6 +102,6 @@ context "Diff in context format" do
 EOD
 
     diff = @differ.diff_as_object(expected,actual)
-    diff.should_eql expected_diff
+    diff.should == expected_diff
   end
 end

data/spec/spec/expectations/extensions/object_spec.rb

@@ -1,46 +1,46 @@
 require File.dirname(__FILE__) + '/../../../spec_helper.rb'
 
-context "Object#should" do
-  setup do
+describe "Object#should" do
+  before(:each) do
     @target = "target"
     @matcher = mock("matcher")
     @matcher.stub!(:matches?).and_return(true)
     @matcher.stub!(:failure_message)
   end
   
-  specify "should accept and interact with a matcher" do
+  it "should accept and interact with a matcher" do
     @matcher.should_receive(:matches?).with(@target).and_return(true)
     
     @target.should @matcher
   end
   
-  specify "should ask for a failure_message when matches? returns false" do
+  it "should ask for a failure_message when matches? returns false" do
     @matcher.should_receive(:matches?).with(@target).and_return(false)
     @matcher.should_receive(:failure_message).and_return("the failure message")
     lambda {
       @target.should @matcher
-    }.should_fail_with "the failure message"
+    }.should fail_with("the failure message")
   end
 end
 
-context "Object#should_not" do
-  setup do
+describe "Object#should_not" do
+  before(:each) do
     @target = "target"
     @matcher = mock("matcher")
   end
   
-  specify "should accept and interact with a matcher" do
+  it "should accept and interact with a matcher" do
     @matcher.should_receive(:matches?).with(@target).and_return(false)
     @matcher.stub!(:negative_failure_message)
     
     @target.should_not @matcher
   end
   
-  specify "should ask for a negative_failure_message when matches? returns true" do
+  it "should ask for a negative_failure_message when matches? returns true" do
     @matcher.should_receive(:matches?).with(@target).and_return(true)
     @matcher.should_receive(:negative_failure_message).and_return("the negative failure message")
     lambda {
       @target.should_not @matcher
-    }.should_fail_with "the negative failure message"
+    }.should fail_with("the negative failure message")
   end
 end

data/spec/spec/expectations/fail_with_spec.rb

@@ -1,71 +1,71 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
-context "Spec::Expectations.fail_with with no diff" do
-  setup do
+describe "Spec::Expectations.fail_with with no diff" do
+  before(:each) do
     @old_differ = Spec::Expectations.differ
     Spec::Expectations.differ = nil
   end
   
-  specify "should handle just a message" do
+  it "should handle just a message" do
     lambda {
       Spec::Expectations.fail_with "the message"
-    }.should_fail_with "the message"
+    }.should fail_with("the message")
   end
   
-  specify "should handle an Array" do
+  it "should handle an Array" do
     lambda {
       Spec::Expectations.fail_with ["the message","expected","actual"]
-    }.should_fail_with "the message"
+    }.should fail_with("the message")
   end
 
-  teardown do
+  after(:each) do
     Spec::Expectations.differ = @old_differ
   end
 end
 
-context "Spec::Expectations.fail_with with diff" do
-  setup do
+describe "Spec::Expectations.fail_with with diff" do
+  before(:each) do
     @old_differ = Spec::Expectations.differ
     @differ = mock("differ")
     Spec::Expectations.differ = @differ
   end
   
-  specify "should not call differ if no expected/actual" do
+  it "should not call differ if no expected/actual" do
     lambda {
       Spec::Expectations.fail_with "the message"
-    }.should_fail_with "the message"
+    }.should fail_with("the message")
   end
   
-  specify "should call differ if expected/actual are presented separately" do
+  it "should call differ if expected/actual are presented separately" do
     @differ.should_receive(:diff_as_string).and_return("diff")
     lambda {
       Spec::Expectations.fail_with "the message", "expected", "actual"
-    }.should_fail_with "the message\nDiff:diff"
+    }.should fail_with("the message\nDiff:diff")
   end
   
-  specify "should call differ if expected/actual are not strings" do
+  it "should call differ if expected/actual are not strings" do
     @differ.should_receive(:diff_as_object).and_return("diff")
     lambda {
       Spec::Expectations.fail_with "the message", :expected, :actual
-    }.should_fail_with "the message\nDiff:diff"
+    }.should fail_with("the message\nDiff:diff")
   end
   
-  specify "should not call differ if expected or actual are procs" do
+  it "should not call differ if expected or actual are procs" do
     @differ.should_not_receive(:diff_as_string)
     @differ.should_not_receive(:diff_as_object)
     lambda {
       Spec::Expectations.fail_with "the message", lambda {}, lambda {}
-    }.should_fail_with "the message"
+    }.should fail_with("the message")
   end
   
-  specify "should call differ if expected/actual are presented in an Array with message" do
+  it "should call differ if expected/actual are presented in an Array with message" do
     @differ.should_receive(:diff_as_string).with("actual","expected").and_return("diff")
     lambda {
       Spec::Expectations.fail_with(["the message", "expected", "actual"])
-    }.should_fail_with /the message\nDiff:diff/
+    }.should fail_with(/the message\nDiff:diff/)
   end
   
-  teardown do
+  after(:each) do
     Spec::Expectations.differ = @old_differ
   end
 end

data/spec/spec/matchers/be_close_spec.rb

@@ -1,33 +1,39 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-context "should be_close(expected, delta)" do
-  specify "should pass if target == expected" do
-    5.0.should be_close(5.0, 0.5)
+module Spec
+  module Matchers
+    describe BeClose do
+      it "should match when value == target" do
+        BeClose.new(5.0, 0.5).matches?(5.0).should be_true
+      end
+      it "should match when value < (target + delta)" do
+        BeClose.new(5.0, 0.5).matches?(5.49).should be_true
+      end
+      it "should match when value > (target - delta)" do
+        BeClose.new(5.0, 0.5).matches?(4.51).should be_true
+      end
+      it "should not match when value == (target - delta)" do
+        BeClose.new(5.0, 0.5).matches?(4.5).should be_false
+      end
+      it "should not match when value < (target - delta)" do
+        BeClose.new(5.0, 0.5).matches?(4.49).should be_false
+      end
+      it "should not match when value == (target + delta)" do
+        BeClose.new(5.0, 0.5).matches?(5.5).should be_false
+      end
+      it "should not match when value > (target + delta)" do
+        BeClose.new(5.0, 0.5).matches?(5.51).should be_false
+      end
+      it "should provide a useful failure message" do
+        #given
+          matcher = BeClose.new(5.0, 0.5)
+        #when
+          matcher.matches?(5.51)
+        #then
+          matcher.failure_message.should == "expected 5.0 +/- (< 0.5), got 5.51"
+      end
+      it "should describe itself" do
+        BeClose.new(5.0, 0.5).description.should == "be close to 5.0 (within +- 0.5)"
+      end
+    end
   end
-  specify "should pass if target < expected + delta" do
-    5.49.should be_close(5.0, 0.5)
-  end
-  specify "should pass if target > expected - delta" do
-    4.51.should be_close(5.0, 0.5)
-  end
-  specify "should fail if target == expected - delta" do
-    lambda { 
-      4.5.should be_close(5.0, 0.5)
-    }.should fail_with("expected 5.0 +/- (<0.5), got 4.5")
-  end
-  specify "should fail if target < expected - delta" do
-    lambda { 
-      4.49.should be_close(5.0, 0.5)
-    }.should fail_with("expected 5.0 +/- (<0.5), got 4.49")
-  end
-  specify "should fail if target == expected + delta" do
-    lambda { 
-      5.5.should be_close(5.0, 0.5)
-    }.should fail_with("expected 5.0 +/- (<0.5), got 5.5")
-  end
-  specify "should fail if target > expected + delta" do
-    lambda { 
-      5.51.should be_close(5.0, 0.5)
-    }.should fail_with("expected 5.0 +/- (<0.5), got 5.51")
-  end
-end
+end