rspec-expectations 2.14.0 → 3.13.0

data/features/custom_matchers/define_matcher.feature

@@ -1,368 +0,0 @@
-Feature: define matcher
-
-  In order to express my domain clearly in my code examples
-  As an RSpec user
-  I want a shortcut to define custom matchers
-
-  Scenario: define a matcher with default messages
-    Given a file named "matcher_with_default_message_spec.rb" with:
-      """ruby
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :be_a_multiple_of do |expected|
-        match do |actual|
-          actual % expected == 0
-        end
-      end
-
-      describe 9 do
-        it {should be_a_multiple_of(3)}
-      end
-
-      describe 9 do
-        it {should_not be_a_multiple_of(4)}
-      end
-
-      # fail intentionally to generate expected output
-      describe 9 do
-        it {should be_a_multiple_of(4)}
-      end
-
-      # fail intentionally to generate expected output
-      describe 9 do
-        it {should_not be_a_multiple_of(3)}
-      end
-
-      """
-    When I run `rspec ./matcher_with_default_message_spec.rb --format documentation`
-    Then the exit status should not be 0
-
-    And the output should contain "should be a multiple of 3"
-    And the output should contain "should not be a multiple of 4"
-    And the output should contain "Failure/Error: it {should be_a_multiple_of(4)}"
-    And the output should contain "Failure/Error: it {should_not be_a_multiple_of(3)}"
-
-    And the output should contain "4 examples, 2 failures"
-    And the output should contain "expected 9 to be a multiple of 4"
-    And the output should contain "expected 9 not to be a multiple of 3"
-
-  Scenario: overriding the failure_message_for_should
-    Given a file named "matcher_with_failure_message_spec.rb" with:
-      """ruby
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :be_a_multiple_of do |expected|
-        match do |actual|
-          actual % expected == 0
-        end
-        failure_message_for_should do |actual|
-          "expected that #{actual} would be a multiple of #{expected}"
-        end
-      end
-
-      # fail intentionally to generate expected output
-      describe 9 do
-        it {should be_a_multiple_of(4)}
-      end
-      """
-    When I run `rspec ./matcher_with_failure_message_spec.rb`
-    Then the exit status should not be 0
-    And the stdout should contain "1 example, 1 failure"
-    And the stdout should contain "expected that 9 would be a multiple of 4"
-
-  Scenario: overriding the failure_message_for_should_not
-    Given a file named "matcher_with_failure_for_message_spec.rb" with:
-      """ruby
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :be_a_multiple_of do |expected|
-        match do |actual|
-          actual % expected == 0
-        end
-        failure_message_for_should_not do |actual|
-          "expected that #{actual} would not be a multiple of #{expected}"
-        end
-      end
-
-      # fail intentionally to generate expected output
-      describe 9 do
-        it {should_not be_a_multiple_of(3)}
-      end
-      """
-    When I run `rspec ./matcher_with_failure_for_message_spec.rb`
-    Then the exit status should not be 0
-    And the stdout should contain "1 example, 1 failure"
-    And the stdout should contain "expected that 9 would not be a multiple of 3"
-
-  Scenario: overriding the description
-    Given a file named "matcher_overriding_description_spec.rb" with:
-      """ruby
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :be_a_multiple_of do |expected|
-        match do |actual|
-          actual % expected == 0
-        end
-        description do
-          "be multiple of #{expected}"
-        end
-      end
-
-      describe 9 do
-        it {should be_a_multiple_of(3)}
-      end
-
-      describe 9 do
-        it {should_not be_a_multiple_of(4)}
-      end
-      """
-    When I run `rspec ./matcher_overriding_description_spec.rb --format documentation`
-    Then the exit status should be 0
-    And the stdout should contain "2 examples, 0 failures"
-    And the stdout should contain "should be multiple of 3"
-    And the stdout should contain "should not be multiple of 4"
-
-  Scenario: with no args
-    Given a file named "matcher_with_no_args_spec.rb" with:
-      """ruby
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :have_7_fingers do
-        match do |thing|
-          thing.fingers.length == 7
-        end
-      end
-
-      class Thing
-        def fingers; (1..7).collect {"finger"}; end
-      end
-
-      describe Thing do
-        it {should have_7_fingers}
-      end
-      """
-    When I run `rspec ./matcher_with_no_args_spec.rb --format documentation`
-    Then the exit status should be 0
-    And the stdout should contain "1 example, 0 failures"
-    And the stdout should contain "should have 7 fingers"
-
-  Scenario: with multiple args
-    Given a file named "matcher_with_multiple_args_spec.rb" with:
-      """ruby
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :be_the_sum_of do |a,b,c,d|
-        match do |sum|
-          a + b + c + d == sum
-        end
-      end
-
-      describe 10 do
-        it {should be_the_sum_of(1,2,3,4)}
-      end
-      """
-    When I run `rspec ./matcher_with_multiple_args_spec.rb --format documentation`
-    Then the exit status should be 0
-    And the stdout should contain "1 example, 0 failures"
-    And the stdout should contain "should be the sum of 1, 2, 3, and 4"
-
-  Scenario: with helper methods
-    Given a file named "matcher_with_internal_helper_spec.rb" with:
-      """ruby
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :have_same_elements_as do |sample|
-        match do |actual|
-          similar?(sample, actual)
-        end
-
-        def similar?(a, b)
-          a.sort == b.sort
-        end
-      end
-
-      describe "these two arrays" do
-        specify "should be similar" do
-          [1,2,3].should have_same_elements_as([2,3,1])
-        end
-      end
-      """
-    When I run `rspec ./matcher_with_internal_helper_spec.rb`
-    Then the exit status should be 0
-    And the stdout should contain "1 example, 0 failures"
-
-  Scenario: scoped in a module
-    Given a file named "scoped_matcher_spec.rb" with:
-      """ruby
-      require 'rspec/expectations'
-
-      module MyHelpers
-        extend RSpec::Matchers::DSL
-
-        matcher :be_just_like do |expected|
-          match {|actual| actual == expected}
-        end
-      end
-
-      describe "group with MyHelpers" do
-        include MyHelpers
-        it "has access to the defined matcher" do
-          5.should be_just_like(5)
-        end
-      end
-
-      describe "group without MyHelpers" do
-        it "does not have access to the defined matcher" do
-          expect do
-            5.should be_just_like(5)
-          end.to raise_exception
-        end
-      end
-      """
-
-    When I run `rspec ./scoped_matcher_spec.rb`
-    Then the stdout should contain "2 examples, 0 failures"
-
-  Scenario: scoped in an example group
-    Given a file named "scoped_matcher_spec.rb" with:
-      """ruby
-      require 'rspec/expectations'
-
-      describe "group with matcher" do
-        matcher :be_just_like do |expected|
-          match {|actual| actual == expected}
-        end
-
-        it "has access to the defined matcher" do
-          5.should be_just_like(5)
-        end
-
-        describe "nested group" do
-          it "has access to the defined matcher" do
-            5.should be_just_like(5)
-          end
-        end
-
-      end
-
-      describe "group without matcher" do
-        it "does not have access to the defined matcher" do
-          expect do
-            5.should be_just_like(5)
-          end.to raise_exception
-        end
-      end
-      """
-
-    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:
-      """ruby
-      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:
-      """ruby
-      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 |
-
-  Scenario: include a module with helper methods in the matcher
-    Given a file named "include_module_spec.rb" with:
-      """ruby
-      module MatcherHelpers
-        def is_multiple?(actual, expected)
-          actual % expected == 0
-        end
-      end
-
-      RSpec::Matchers.define :be_a_multiple_of do |expected|
-        include MatcherHelpers
-        match { |actual| is_multiple?(actual, expected) }
-      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 include_module_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 |
-
-  Scenario: matching against a regular expression
-    Given a file named "regular_expression_matcher_spec.rb" with:
-      """ruby
-      # Due to Ruby's method dispatch mechanism, use the `#match_regex` alias
-      # rather than the `#match` matcher when defining custom matchers via the
-      # DSL.
-
-      RSpec::Matchers.define :be_valid_us_zipcode do
-        match do |actual|
-          expect(actual).to match_regex(/\A\d{5}(-\d{4})?\z/)
-        end
-      end
-
-      describe "30316" do
-        it { should be_valid_us_zipcode }
-      end
-
-      describe "30316-0001" do
-        it { should be_valid_us_zipcode }
-      end
-
-      describe "1000-61303" do
-        it { should_not be_valid_us_zipcode }
-      end
-      """
-    When I run `rspec regular_expression_matcher_spec.rb`
-    Then the stdout should contain "3 examples, 0 failures"

data/features/custom_matchers/define_matcher_outside_rspec.feature

@@ -1,38 +0,0 @@
-Feature: define matcher outside rspec
-
-  In order to express my domain clearly in my code examples
-  As a non-rspec user
-  I want a shortcut to define custom matchers
-
-  Scenario: define a matcher with default messages
-    Given a file named "test_multiples.rb" with:
-      """ruby
-      require "rspec/expectations"
-      require "test/unit"
-
-      RSpec::Matchers.define :be_a_multiple_of do |expected|
-        match do |actual|
-          actual % expected == 0
-        end
-      end
-
-      class Test::Unit::TestCase
-        include RSpec::Matchers
-      end
-
-      class TestMultiples < Test::Unit::TestCase
-
-        def test_9_should_be_a_multiple_of_3
-          9.should be_a_multiple_of(3)
-        end
-
-        def test_9_should_be_a_multiple_of_4
-          9.should be_a_multiple_of(4)
-        end
-
-      end
-      """
-    When I run `ruby test_multiples.rb`
-    Then the exit status should not be 0
-    And the output should contain "expected 9 to be a multiple of 4"
-    And the output should contain "2 tests, 0 assertions, 0 failures, 1 errors"

data/features/custom_matchers/define_matcher_with_fluent_interface.feature

@@ -1,24 +0,0 @@
-Feature: define matcher with fluent interface
-
-  Use the chain() method to define matchers with a fluent interface.
-
-  Scenario: chained method with argumetn
-    Given a file named "between_spec.rb" with:
-      """ruby
-      RSpec::Matchers.define :be_bigger_than do |first|
-        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`
-    Then the output should contain "1 example, 0 failures"
-    And  the output should contain "should be bigger than 4"

data/features/customized_message.feature

@@ -1,22 +0,0 @@
-Feature: customized message
-
-  RSpec tries to provide useful failure messages, but for cases in which you
-  want more specific information, you can define your own message right in the
-  example. This works for any matcher _other than the operator matchers_.
-
-  Scenario: customize failure message
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe Array do
-        context "when created with `new`" do
-          it "is empty" do
-            array = Array.new
-            array << 1 # trigger a failure to demonstrate the message
-            array.should be_empty, "expected empty array, got #{array.inspect}"
-          end
-        end
-      end
-
-      """
-    When I run `rspec example_spec.rb --format documentation`
-    Then the output should contain "expected empty array, got [1]"

data/features/diffing.feature

@@ -1,85 +0,0 @@
-Feature: diffing
-
-  When appropriate, failure messages will automatically include a diff.
-
-  Scenario: diff for a multiline string
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "a multiline string" do
-        it "is like another string" do
-          expected = <<-EXPECTED
-      this is the
-        expected
-          string
-      EXPECTED
-          actual = <<-ACTUAL
-      this is the
-        actual
-          string
-      ACTUAL
-          actual.should eq(expected)
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should contain:
-      """
-             Diff:
-             @@ -1,4 +1,4 @@
-              this is the
-             -  expected
-             +  actual
-                  string
-      """
-
-  Scenario: diff for a multiline string and a regexp
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "a multiline string" do
-        it "is like another string" do
-          expected = /expected/m
-          actual = <<-ACTUAL
-      this is the
-        actual
-          string
-      ACTUAL
-          actual.should =~ expected
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should contain:
-      """
-             Diff:
-             @@ -1,2 +1,4 @@
-             -/expected/m
-             +this is the
-             +  actual
-             +    string
-      """
-
-  Scenario: no diff for a single line strings
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "a single line string" do
-        it "is like another string" do
-          expected = "this string"
-          actual   = "that string"
-          actual.should eq(expected)
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should not contain "Diff:"
-
-  Scenario: no diff for numbers
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "a number" do
-        it "is like another number" do
-          1.should eq(2)
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should not contain "Diff:"

data/features/implicit_docstrings.feature

@@ -1,52 +0,0 @@
-Feature: implicit docstrings
-
-  As an RSpec user
-  I want examples to generate their own names
-  So that I can reduce duplication between example names and example code
-
-  Scenario: run passing examples
-    Given a file named "implicit_docstrings_spec.rb" with:
-    """ruby
-    describe "Examples with no docstrings generate their own:" do
-
-      specify { 3.should be < 5 }
-
-      specify { [1,2,3].should include(2) }
-
-      specify { [1,2,3].should respond_to(:size) }
-
-    end
-    """
-
-    When I run `rspec ./implicit_docstrings_spec.rb -fdoc`
-
-    Then the output should contain "should be < 5"
-    And the output should contain "should include 2"
-    And the output should contain "should respond to #size"
-
-  Scenario: run failing examples
-    Given a file named "failing_implicit_docstrings_spec.rb" with:
-    """ruby
-    describe "Failing examples with no descriptions" do
-
-      # description is auto-generated as "should equal(5)" based on the last #should
-      it do
-        3.should equal(2)
-        5.should equal(5)
-      end
-
-      it { 3.should be > 5 }
-
-      it { [1,2,3].should include(4) }
-
-      it { [1,2,3].should_not respond_to(:size) }
-
-    end
-    """
-
-    When I run `rspec ./failing_implicit_docstrings_spec.rb -fdoc`
-
-    Then the output should contain "should equal 2"
-    And the output should contain "should be > 5"
-    And the output should contain "should include 4"
-    And the output should contain "should not respond to #size"

data/features/step_definitions/additional_cli_steps.rb

@@ -1,22 +0,0 @@
-# Useful for when the output is slightly different on different versions of ruby
-Then /^the output should contain "([^"]*)" or "([^"]*)"$/ do |string1, string2|
-  unless [string1, string2].any? { |s| all_output =~ regexp(s) }
-    fail %Q{Neither "#{string1}" or "#{string2}" were found in:\n#{all_output}}
-  end
-end
-
-Then /^the output should contain all of these:$/ do |table|
-  table.raw.flatten.each do |string|
-    assert_partial_output(string, all_output)
-  end
-end
-
-Then /^the example(?:s)? should(?: all)? pass$/ do
-  step %q{the output should contain "0 failures"}
-  step %q{the exit status should be 0}
-end
-
-Then /^the example should fail$/ do
-  step %q{the output should contain "1 failure"}
-  step %q{the exit status should not be 0}
-end

data/features/support/env.rb

@@ -1,14 +0,0 @@
-require 'aruba/cucumber'
-
-timeouts = { 'java' => 60 }
-
-Before do
-  @aruba_timeout_seconds = timeouts.fetch(RUBY_PLATFORM) { 15 }
-end
-
-Aruba.configure do |config|
-  config.before_cmd do |cmd|
-    set_env('JRUBY_OPTS', "-X-C #{ENV['JRUBY_OPTS']}") # disable JIT since these processes are so short lived
-  end
-end if RUBY_PLATFORM == 'java'
-

data/features/syntax_configuration.feature

@@ -1,71 +0,0 @@
-Feature: Syntax Configuration
-
-  In addition to the long-supported `should` syntax, rspec-expectations
-  supports an alternate `expect` syntax. If you want your project to
-  only use one syntax, you can configure the available syntaxes.
-
-  Background:
-    Given a file named "syntaxes_spec.rb" with:
-      """ruby
-      describe "using the should syntax" do
-        specify { 3.should eq(3) }
-        specify { 3.should_not eq(4) }
-        specify { lambda { raise "boom" }.should raise_error("boom") }
-        specify { lambda { }.should_not raise_error }
-      end
-
-      describe "using the expect syntax" do
-        specify { expect(3).to eq(3) }
-        specify { expect(3).not_to eq(4) }
-        specify { expect { raise "boom" }.to raise_error("boom") }
-        specify { expect { }.not_to raise_error }
-      end
-      """
-
-  Scenario: Both syntaxes are available by default
-    When I run `rspec syntaxes_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Disable should syntax
-    Given a file named "disable_should_syntax.rb" with:
-      """ruby
-      RSpec.configure do |config|
-        config.expect_with :rspec do |c|
-          c.syntax = :expect
-        end
-      end
-      """
-    When I run `rspec disable_should_syntax.rb syntaxes_spec.rb`
-    Then the output should contain all of these:
-      | 8 examples, 4 failures    |
-      | undefined method `should' |
-
-  Scenario: Disable expect syntax
-    Given a file named "disable_expect_syntax.rb" with:
-      """ruby
-      RSpec.configure do |config|
-        config.expect_with :rspec do |c|
-          c.syntax = :should
-        end
-        config.mock_with :rspec do |c|
-          c.syntax = :should
-        end
-      end
-      """
-    When I run `rspec disable_expect_syntax.rb syntaxes_spec.rb`
-    Then the output should contain all of these:
-      | 8 examples, 4 failures    |
-      | undefined method `expect' |
-
-  Scenario: Explicitly enable both syntaxes
-    Given a file named "enable_both_syntaxes.rb" with:
-      """ruby
-      RSpec.configure do |config|
-        config.expect_with :rspec do |c|
-          c.syntax = [:should, :expect]
-        end
-      end
-      """
-    When I run `rspec enable_both_syntaxes.rb syntaxes_spec.rb`
-    Then the examples should all pass
-