rspec-expectations 2.0.0.rc → 2.0.0

data/Gemfile

@@ -10,6 +10,7 @@ gem "rspec-core", :path => "../rspec-core"
 gem "rspec-mocks", :path => "../rspec-mocks"
 gem "watchr"
 gem "rcov"
+gem "relish"
 
 case RUBY_VERSION
 when '1.9.2'

data/History.markdown

@@ -1,5 +1,16 @@
 ## rspec-expectations release history (incomplete)
 
+### 2.0.0 / 2010-10-10
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.0.0.rc...v2.0.0)
+
+* Enhancements
+  * Add match_for_should_not method to matcher DSL (Myron Marston)
+
+* Bug fixes
+  * respond_to matcher works correctly with should_not with multiple methods (Myron Marston)
+  * include matcher works correctly with should_not with multiple values (Myron Marston)
+
 ### 2.0.0.rc / 2010-10-05
 
 [full changelog](http://github.com/rspec/rspec-expectations/compare/v2.0.0.beta.22...v2.0.0.rc)

data/Rakefile

@@ -8,8 +8,6 @@ require 'rspec/core/rake_task'
 require 'rspec/expectations/version'
 require 'cucumber/rake/task'
 
-RSpec::Core::RakeTask.new(:spec)
-
 class Cucumber::Rake::Task::ForkedCucumberRunner
   # When cucumber shells out, we still need it to run in the context of our
   # bundle.
@@ -18,22 +16,34 @@ class Cucumber::Rake::Task::ForkedCucumberRunner
   end
 end
 
-desc "Run all examples using rcov"
-RSpec::Core::RakeTask.new :rcov => :cleanup_rcov_files do |t|
-  t.rcov = true
-  t.rcov_opts =  %[-Ilib -Ispec --exclude "gems/*,features"]
-  t.rcov_opts << %[--text-report --sort coverage --no-html --aggregate coverage.data]
-end
-
 task :cleanup_rcov_files do
   rm_rf 'coverage.data'
 end
 
-Cucumber::Rake::Task.new :cucumber => :cleanup_rcov_files do |t|
-  t.cucumber_opts = %w{--format progress}
-  t.rcov = true
-  t.rcov_opts =  %[-Ilib -Ispec --exclude "gems/*,features"]
-  t.rcov_opts << %[--text-report --sort coverage --aggregate coverage.data]
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = %w[--color]
+end
+
+Cucumber::Rake::Task.new(:cucumber)
+
+namespace :spec do
+  desc "Run all examples using rcov"
+  RSpec::Core::RakeTask.new :rcov => :cleanup_rcov_files do |t|
+    t.rcov = true
+    t.rcov_opts =  %[-Ilib -Ispec --exclude "gems/*,features"]
+    t.rcov_opts << %[--text-report --sort coverage --no-html --aggregate coverage.data]
+  end
+end
+
+namespace :cucumber do
+  desc "Run cucumber features using rcov"
+  Cucumber::Rake::Task.new :rcov => :cleanup_rcov_files do |t|
+    t.cucumber_opts = %w{--format progress}
+    t.rcov = true
+    t.rcov_opts =  %[-Ilib -Ispec --exclude "gems/*,features"]
+    t.rcov_opts << %[--text-report --sort coverage --aggregate coverage.data]
+  end
 end
 
 task :default => [:spec, :cucumber]
@@ -45,6 +55,12 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
+desc "Push cukes to relishapp using the relish-client-gem"
+task :relish, :version do |t, args|
+  raise "rake relish[VERSION]" unless args[:version]
+  sh "bundle exec relish --organization rspec --project rspec-expectations -v #{args[:version]} push"
+end
+
 task :clobber do
   rm_rf 'doc'
   rm_rf 'pkg'

data/features/README.markdown

@@ -1,12 +1,18 @@
-# Cucumber features
+rspec-expectations is used to set expectations in executable
+examples:
 
-RSpec is specified using both RSpec and
-[Cucumber](http://github.com/aslakhellesoy/cucumber). Cucumber provides
-_executable documentation_.  This means that the _.feature_ files below this
-directory serve as specification, documentation _and_ regression tests of the
-behaviour.
+    describe Account do
+      it "has a balance of zero when first created" do
+        Account.new.balance.should eq(Money.new(0))
+      end
+    end
 
 ## Issues
 
-If you find this documentation incomplete or confusing, please [submit an
-issue](http://github.com/rspec/rspec-expectations/issues).
+The documentation for rspec-expectations is a work in progress. We'll be adding
+Cucumber features over time, and clarifying existing ones.  If you have
+specific features you'd like to see added, find the existing documentation
+incomplete or confusing, or, better yet, wish to write a missing Cucumber
+feature yourself, please [submit an
+issue](http://github.com/rspec/rspec-expectations/issues) or a [pull
+request](http://github.com/rspec/rspec-expectations).

data/features/matchers/access_running_example.feature

@@ -1,4 +1,4 @@
-Feature: access running example
+Feature: Access running example
 
   In order to take advantage of services that are available
     in my examples when I'm writing matchers

data/features/matchers/define_diffable_matcher.feature

@@ -1,4 +1,4 @@
-Feature: define diffable matcher
+Feature: Define diffable matcher
 
   When a matcher is defined as diffable, and the --diff
   flag is set, the output will include a diff of the submitted

data/features/matchers/define_matcher.feature

@@ -1,4 +1,4 @@
-Feature: define matcher
+Feature: Define matcher
 
   In order to express my domain clearly in my code examples
   As an RSpec user
@@ -256,3 +256,56 @@ Feature: define matcher
 
     When I run "rspec scoped_matcher_spec.rb"
     Then the output should contain "3 examples, 0 failures"
+
+  Scenario: matcher with separate logic for should and should_not
+    Given a file named "matcher_with_separate_should_not_logic_spec.rb" with:
+      """
+      RSpec::Matchers.define :contain do |*expected|
+        match_for_should do |actual|
+          expected.all? { |e| actual.include?(e) }
+        end
+
+        match_for_should_not do |actual|
+          expected.none? { |e| actual.include?(e) }
+        end
+      end
+
+      describe [1, 2, 3] do
+        it { should contain(1, 2) }
+        it { should_not contain(4, 5, 6) }
+
+        # deliberate failures
+        it { should contain(1, 4) }
+        it { should_not contain(1, 4) }
+      end
+      """
+    When I run "rspec matcher_with_separate_should_not_logic_spec.rb"
+    Then the output should contain all of these:
+      | 4 examples, 2 failures                    |
+      | expected [1, 2, 3] to contain 1 and 4     |
+      | expected [1, 2, 3] not to contain 1 and 4 |
+
+  Scenario: use define_method to create a helper method with access to matcher params
+    Given a file named "define_method_spec.rb" with:
+      """
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        define_method :is_multiple? do |actual|
+          actual % expected == 0
+        end
+        match { |actual| is_multiple?(actual) }
+      end
+
+      describe 9 do
+        it { should be_a_multiple_of(3) }
+        it { should_not be_a_multiple_of(4) }
+
+        # deliberate failures
+        it { should be_a_multiple_of(2) }
+        it { should_not be_a_multiple_of(3) }
+      end
+      """
+    When I run "rspec define_method_spec.rb"
+    Then the output should contain all of these:
+      | 4 examples, 2 failures               |
+      | expected 9 to be a multiple of 2     |
+      | expected 9 not to be a multiple of 3 |

data/features/matchers/define_matcher_outside_rspec.feature

@@ -1,4 +1,4 @@
-Feature: define matcher outside rspec
+Feature: Define matcher outside rspec
 
   In order to express my domain clearly in my code examples
   As a non-rspec user

data/features/matchers/define_matcher_with_fluent_interface.feature

@@ -1,27 +1,24 @@
-Feature: define matcher
+Feature: Define matcher with fluent interface
 
-  In order to express my domain clearly in my code examples
-  As an RSpec user
-  I want to define matchers with fluent interfaces
+  Use the chain() method to define matchers with a fluent interface.
   
-  Scenario: one additional method
+  Scenario: chained method with argumetn
     Given a file named "between_spec.rb" with:
       """
       RSpec::Matchers.define :be_bigger_than do |first|
-        def but_smaller_than(second)
-          @second = second
-          self
-        end
-        
         match do |actual|
           (actual > first) && (actual < @second)
         end
+
+        chain :but_smaller_than do |second|
+          @second = second
+        end
       end
 
       describe 5 do
         it { should be_bigger_than(4).but_smaller_than(6) }
       end
       """
-    When I run "rspec ./between_spec.rb --format documentation"
+    When I run "rspec between_spec.rb --format documentation"
     Then the output should contain "1 example, 0 failures"
     And  the output should contain "should be bigger than 4"

data/features/matchers/equality.feature

@@ -1,4 +1,4 @@
-Feature: equality matchers
+Feature: Equality matchers
 
   Ruby exposes several different methods for handling equality:
 

data/features/matchers/expect_change.feature

@@ -1,4 +1,4 @@
-Feature: expect change
+Feature: Expect change
 
   Expect some code (wrapped in a proc) to change the state of some object.
   

data/features/matchers/expect_error.feature

@@ -1,4 +1,4 @@
-Feature: expect error
+Feature: Expect error
 
   Expect a proc to raise an error when called.
   

data/features/matchers/have.feature

@@ -1,4 +1,4 @@
-Feature: have matchers
+Feature: have(n).items matcher
 
   RSpec provides several matchers that make it easy to set expectations about the
   size of a collection.  There are three basic forms:

data/features/matchers/include.feature

@@ -0,0 +1,136 @@
+Feature: include matcher
+
+  Use the include matcher to specify than a collection includes one or more
+  expected objects.  This works on any object that responds to #include?  (such
+  as a string or array):
+
+    "a string".should include("a")
+    "a string".should include("str")
+    "a string".should include("str", "g")
+    "a string".should_not include("foo")
+
+    [1, 2].should include(1)
+    [1, 2].should include(1, 2)
+    [1, 2].should_not include(17)
+
+  The matcher also provides flexible handling for hashes:
+
+    {:a => 1, :b => 2}.should include(:a)
+    {:a => 1, :b => 2}.should include(:a, :b)
+    {:a => 1, :b => 2}.should include(:a => 1)
+    {:a => 1, :b => 2}.should include(:b => 2, :a => 1)
+    {:a => 1, :b => 2}.should_not include(:c)
+    {:a => 1, :b => 2}.should_not include(:a => 2)
+    {:a => 1, :b => 2}.should_not include(:c => 3)
+
+  Scenario: array usage
+    Given a file named "array_include_matcher_spec.rb" with:
+      """
+      describe [1, 3, 7] do
+        it { should include(1) }
+        it { should include(3) }
+        it { should include(7) }
+        it { should include(1, 7) }
+        it { should include(1, 3, 7) }
+        it { should_not include(17) }
+        it { should_not include(43, 100) }
+
+        # deliberate failures
+        it { should include(4) }
+        it { should_not include(1) }
+        it { should_not include(3) }
+        it { should_not include(7) }
+        it { should_not include(1, 3, 7) }
+
+        # both of these should fail since it includes 1 but not 9
+        it { should include(1, 9) }
+        it { should_not include(1, 9) }
+      end
+      """
+    When I run "rspec array_include_matcher_spec.rb"
+    Then the output should contain all of these:
+      | 14 examples, 7 failures                       |
+      | expected [1, 3, 7] to include 4               |
+      | expected [1, 3, 7] not to include 1           |
+      | expected [1, 3, 7] not to include 3           |
+      | expected [1, 3, 7] not to include 7           |
+      | expected [1, 3, 7] not to include 1, 3, and 7 |
+      | expected [1, 3, 7] to include 1 and 9         |
+      | expected [1, 3, 7] not to include 1 and 9     |
+
+  Scenario: string usage
+    Given a file named "string_include_matcher_spec.rb" with:
+      """
+      describe "a string" do
+        it { should include("str") }
+        it { should include("a", "str", "ng") }
+        it { should_not include("foo") }
+        it { should_not include("foo", "bar") }
+
+        # deliberate failures
+        it { should include("foo") }
+        it { should_not include("str") }
+        it { should include("str", "foo") }
+        it { should_not include("str", "foo") }
+      end
+      """
+    When I run "rspec string_include_matcher_spec.rb"
+    Then the output should contain all of these:
+      | 8 examples, 4 failures                             |
+      | expected "a string" to include "foo"               |
+      | expected "a string" not to include "str"           |
+      | expected "a string" to include "str" and "foo"     |
+      | expected "a string" not to include "str" and "foo" |
+
+  Scenario: hash usage
+    Given a file named "hash_include_matcher_spec.rb" with:
+      """
+      describe Hash do
+        subject { { :a => 7, :b => 5 } }
+
+        it { should include(:a) }
+        it { should include(:b, :a) }
+        it { should include(:a => 7) }
+        it { should include(:b => 5, :a => 7) }
+        it { should_not include(:c) }
+        it { should_not include(:c, :d) }
+        it { should_not include(:d => 2) }
+        it { should_not include(:a => 5) }
+        it { should_not include(:b => 7, :a => 5) }
+
+        # deliberate failures
+        it { should_not include(:a) }
+        it { should_not include(:b, :a) }
+        it { should_not include(:a => 7) }
+        it { should_not include(:a => 7, :b => 5) }
+        it { should include(:c) }
+        it { should include(:c, :d) }
+        it { should include(:d => 2) }
+        it { should include(:a => 5) }
+        it { should include(:a => 5, :b => 7) }
+
+        # Mixed cases--the hash includes one but not the other.
+        # All 4 of these cases should fail.
+        it { should include(:a, :d) }
+        it { should_not include(:a, :d) }
+        it { should include(:a => 7, :d => 3) }
+        it { should_not include(:a => 7, :d => 3) }
+      end
+      """
+    When I run "rspec hash_include_matcher_spec.rb"
+    Then the output should contain all of these:
+      | 22 examples, 13 failures                              |
+      | expected {:a=>7, :b=>5} not to include :a             |
+      | expected {:a=>7, :b=>5} not to include :b and :a      |
+      | expected {:a=>7, :b=>5} not to include {:a=>7}        |
+      | expected {:a=>7, :b=>5} not to include {:a=>7, :b=>5} |
+      | expected {:a=>7, :b=>5} to include :c                 |
+      | expected {:a=>7, :b=>5} to include :c and :d          |
+      | expected {:a=>7, :b=>5} to include {:d=>2}            |
+      | expected {:a=>7, :b=>5} to include {:a=>5}            |
+      | expected {:a=>7, :b=>5} to include {:a=>5, :b=>7}     |
+      | expected {:a=>7, :b=>5} to include :a and :d          |
+      | expected {:a=>7, :b=>5} not to include :a and :d      |
+      | expected {:a=>7, :b=>5} to include {:a=>7, :d=>3}     |
+      | expected {:a=>7, :b=>5} not to include {:a=>7, :d=>3} |
+

data/features/matchers/operators.feature

@@ -1,4 +1,4 @@
-Feature: Operator Matchers
+Feature: Operator matchers
 
   RSpec provides a number of matchers that are based on Ruby's built-in
   operators.  These mostly work like you expect.  For example, each of these pass:

data/features/matchers/predicates.feature

@@ -1,4 +1,4 @@
-Feature: predicate matchers
+Feature: Predicate matchers
 
   Ruby objects commonly provide predicate methods:
 

data/features/matchers/respond_to.feature

@@ -0,0 +1,78 @@
+Feature: respond_to matcher
+
+  Use the respond_to matcher to specify details of an object's interface.  In
+  its most basic form:
+
+    obj.should respond_to(:foo) # pass if obj.respond_to?(:foo)
+
+  You can specify that an object responds to multiple messages in a single
+  statement with multiple arguments passed to the matcher
+    
+    obj.should respond_to(:foo, :bar) # passes if obj.respond_to?(:foo) && obj.respond_to?(:bar)
+
+  If the number of arguments accepted by the method is important to you,
+  you can specify that as well:
+
+    obj.should respond_to(:foo).with(1).argument
+    obj.should respond_to(:bar).with(2).arguments
+
+  Note that this matcher relies entirely upon #respond_to?.  If an object
+  dynamically responds to a message via #method_missing, but does not indicate
+  this via #respond_to?, then this matcher will give you false results.
+
+  Scenario: basic usage
+    Given a file named "respond_to_matcher_spec.rb" with:
+      """
+      describe "a string" do
+        it { should respond_to(:length) }
+        it { should respond_to(:hash, :class, :to_s) }
+        it { should_not respond_to(:to_model) }
+        it { should_not respond_to(:compact, :flatten) }
+
+        # deliberate failures
+        it { should respond_to(:to_model) }
+        it { should respond_to(:compact, :flatten) }
+        it { should_not respond_to(:length) }
+        it { should_not respond_to(:hash, :class, :to_s) }
+
+        # mixed examples--String responds to :length but not :flatten
+        # both specs should fail
+        it { should respond_to(:length, :flatten) }
+        it { should_not respond_to(:length, :flatten) }
+      end
+      """
+    When I run "rspec respond_to_matcher_spec.rb"
+    Then the output should contain all of these:
+      | 10 examples, 6 failures                                    |
+      | expected "a string" to respond to :to_model                |
+      | expected "a string" to respond to :compact, :flatten       |
+      | expected "a string" not to respond to :length              |
+      | expected "a string" not to respond to :hash, :class, :to_s |
+      | expected "a string" to respond to :flatten                 |
+      | expected "a string" not to respond to :length              |
+
+  Scenario: specify arguments
+    Given a file named "respond_to_matcher_argument_checking_spec.rb" with:
+      """
+      describe 7 do
+        it { should respond_to(:zero?).with(0).arguments }
+        it { should_not respond_to(:zero?).with(1).argument }
+
+        it { should respond_to(:between?).with(2).arguments }
+        it { should_not respond_to(:between?).with(7).arguments }
+
+        # deliberate failures
+        it { should respond_to(:zero?).with(1).argument }
+        it { should_not respond_to(:zero?).with(0).arguments }
+
+        it { should respond_to(:between?).with(7).arguments }
+        it { should_not respond_to(:between?).with(2).arguments }
+      end
+      """
+    When I run "rspec respond_to_matcher_argument_checking_spec.rb"
+    Then the output should contain all of these:
+      | 8 examples, 4 failures                                  |
+      | expected 7 to respond to :zero? with 1 argument         |
+      | expected 7 not to respond to :zero? with 0 arguments    |
+      | expected 7 to respond to :between? with 7 arguments     |
+      | expected 7 not to respond to :between? with 2 arguments |