rspec-core 2.99.0 → 3.0.0

data/features/example_groups/shared_examples.feature

@@ -1,294 +0,0 @@
-Feature: shared examples
-
-  Shared examples let you describe behaviour of types or modules. When
-  declared, a shared group's content is stored. It is only realized in the
-  context of another example group, which provides any context the shared group
-  needs to run.
-
-  A shared group is included in another group using any of:
-
-      include_examples "name"      # include the examples in the current context
-      it_behaves_like "name"       # include the examples in a nested context
-      it_should_behave_like "name" # include the examples in a nested context
-      matching metadata            # include the examples in the current context
-
-  WARNING: Files containing shared groups must be loaded before the files that
-  use them.  While there are conventions to handle this, RSpec does _not_ do
-  anything special (like autoload). Doing so would require a strict naming
-  convention for files that would break existing suites.
-
-  CONVENTIONS:
-
-  1.  The simplest approach is to require files with shared examples explicitly
-      from the files that use them. Keep in mind that RSpec adds the `spec`
-      directory to the `LOAD_PATH`, so you can say `require
-      'shared_examples_for_widgets'` to require a file at
-      `#{PROJECT_ROOT}/spec/shared_examples_for_widgets.rb`.
-
-  2.  Put files containing shared examples in `spec/support/` and require files
-      in that directory from `spec/spec_helper.rb`:
-
-          Dir["./spec/support/**/*.rb"].sort.each {|f| require f}
-
-      This is included in the generated `spec/spec_helper.rb` file in
-      `rspec-rails`
-
-  3. When all of the groups that include the shared group, just declare
-     the shared group in the same file.
-
-  Scenario: shared examples group included in two groups in one file
-    Given a file named "collection_spec.rb" with:
-      """ruby
-      require "set"
-
-      shared_examples "a collection" do
-        let(:collection) { described_class.new([7, 2, 4]) }
-
-        context "initialized with 3 items" do
-          it "says it has three items" do
-            collection.size.should eq(3)
-          end
-        end
-
-        describe "#include?" do
-          context "with an an item that is in the collection" do
-            it "returns true" do
-              collection.include?(7).should be_truthy
-            end
-          end
-
-          context "with an an item that is not in the collection" do
-            it "returns false" do
-              collection.include?(9).should be_falsey
-            end
-          end
-        end
-      end
-
-      describe Array do
-        it_behaves_like "a collection"
-      end
-
-      describe Set do
-        it_behaves_like "a collection"
-      end
-      """
-    When I run `rspec collection_spec.rb --format documentation`
-    Then the examples should all pass
-    And the output should contain:
-      """
-      Array
-        behaves like a collection
-          initialized with 3 items
-            says it has three items
-          #include?
-            with an an item that is in the collection
-              returns true
-            with an an item that is not in the collection
-              returns false
-
-      Set
-        behaves like a collection
-          initialized with 3 items
-            says it has three items
-          #include?
-            with an an item that is in the collection
-              returns true
-            with an an item that is not in the collection
-              returns false
-      """
-
-  Scenario: Providing context to a shared group using a block
-    Given a file named "shared_example_group_spec.rb" with:
-    """ruby
-    require "set"
-
-    shared_examples "a collection object" do
-      describe "<<" do
-        it "adds objects to the end of the collection" do
-          collection << 1
-          collection << 2
-          expect(collection.to_a).to match_array([1, 2])
-        end
-      end
-    end
-
-    describe Array do
-      it_behaves_like "a collection object" do
-        let(:collection) { Array.new }
-      end
-    end
-
-    describe Set do
-      it_behaves_like "a collection object" do
-        let(:collection) { Set.new }
-      end
-    end
-    """
-    When I run `rspec shared_example_group_spec.rb --format documentation`
-    Then the examples should all pass
-    And the output should contain:
-      """
-      Array
-        behaves like a collection object
-          <<
-            adds objects to the end of the collection
-
-      Set
-        behaves like a collection object
-          <<
-            adds objects to the end of the collection
-      """
-
-  Scenario: Passing parameters to a shared example group
-    Given a file named "shared_example_group_params_spec.rb" with:
-    """ruby
-    shared_examples "a measurable object" do |measurement, measurement_methods|
-      measurement_methods.each do |measurement_method|
-        it "should return #{measurement} from ##{measurement_method}" do
-          subject.send(measurement_method).should == measurement
-        end
-      end
-    end
-
-    describe Array, "with 3 items" do
-      subject { [1, 2, 3] }
-      it_should_behave_like "a measurable object", 3, [:size, :length]
-    end
-
-    describe String, "of 6 characters" do
-      subject { "FooBar" }
-      it_should_behave_like "a measurable object", 6, [:size, :length]
-    end
-    """
-    When I run `rspec shared_example_group_params_spec.rb --format documentation`
-    Then the examples should all pass
-    And the output should contain:
-      """
-      Array with 3 items
-        it should behave like a measurable object
-          should return 3 from #size
-          should return 3 from #length
-
-      String of 6 characters
-        it should behave like a measurable object
-          should return 6 from #size
-          should return 6 from #length
-      """
-
-  Scenario: Aliasing "it_should_behave_like" to "it_has_behavior"
-    Given a file named "shared_example_group_spec.rb" with:
-      """ruby
-      RSpec.configure do |c|
-        c.alias_it_should_behave_like_to :it_has_behavior, 'has behavior:'
-      end
-
-      shared_examples 'sortability' do
-        it 'responds to <=>' do
-          sortable.should respond_to(:<=>)
-        end
-      end
-
-      describe String do
-        it_has_behavior 'sortability' do
-          let(:sortable) { 'sample string' }
-        end
-      end
-      """
-    When I run `rspec shared_example_group_spec.rb --format documentation`
-    Then the examples should all pass
-    And the output should contain:
-      """
-      String
-        has behavior: sortability
-          responds to <=>
-      """
-
-  Scenario: Sharing metadata automatically includes shared example groups
-    Given a file named "shared_example_metadata_spec.rb" with:
-      """ruby
-      shared_examples "shared stuff", :a => :b do
-        it 'runs wherever the metadata is shared' do
-        end
-      end
-
-      describe String, :a => :b do
-      end
-      """
-      When I run `rspec shared_example_metadata_spec.rb`
-      Then the output should contain:
-        """
-        1 example, 0 failures
-        """
-
-  Scenario: Shared examples are nestable by context
-    Given a file named "context_specific_examples_spec.rb" with:
-      """Ruby
-      describe "shared examples" do
-        context "per context" do
-
-          shared_examples "shared examples are nestable" do
-            specify { expect(true).to eq true }
-          end
-
-          it_behaves_like "shared examples are nestable"
-        end
-      end
-      """
-    When I run `rspec context_specific_examples_spec.rb`
-    Then the output should contain:
-      """
-      1 example, 0 failures
-      """
-
-  Scenario: Shared examples are accessible from offspring contexts
-    Given a file named "context_specific_examples_spec.rb" with:
-      """Ruby
-      describe "shared examples" do
-        shared_examples "shared examples are nestable" do
-          specify { expect(true).to eq true }
-        end
-
-        context "per context" do
-          it_behaves_like "shared examples are nestable"
-        end
-      end
-      """
-    When I run `rspec context_specific_examples_spec.rb`
-    Then the output should contain:
-      """
-      1 example, 0 failures
-      """
-    And the output should not contain:
-      """
-      Accessing shared_examples defined across contexts is deprecated
-      """
-
-  Scenario: Shared examples are isolated per context
-    Given a file named "isolated_shared_examples_spec.rb" with:
-      """Ruby
-      describe "shared examples" do
-        context do
-          shared_examples "shared examples are isolated" do
-            specify { expect(true).to eq true }
-          end
-        end
-
-        context do
-          it_behaves_like "shared examples are isolated"
-        end
-      end
-      """
-    When I run `rspec isolated_shared_examples_spec.rb`
-    Then the output should contain:
-      """
-      1 example, 0 failures
-      """
-    But the output should contain:
-      """
-      Accessing shared_examples defined across contexts is deprecated
-      """
-    And the output should contain:
-      """
-      isolated_shared_examples_spec.rb:9
-      """

data/features/expectation_framework_integration/configure_expectation_framework.feature

@@ -1,197 +0,0 @@
-Feature: configure expectation framework
-
-  By default, RSpec is configured to include rspec-expectations for expressing
-  desired outcomes. You can also configure RSpec to use:
-
-  * rspec/expectations (explicitly)
-  * stdlib assertions **DEPRECATED: Use test/unit or minitest explicitly**
-  * test/unit assertions
-  * minitest assertions
-  * any combination of the above libraries
-
-  Note that when you do not use rspec-expectations, you must explicitly provide
-  a description to every example.  You cannot rely on the generated descriptions
-  provided by rspec-expectations.
-
-  Scenario: Default configuration uses rspec-expectations
-    Given a file named "example_spec.rb" with:
-      """ruby
-      RSpec::Matchers.define :be_a_multiple_of do |factor|
-        match do |actual|
-          actual % factor == 0
-        end
-      end
-
-      describe 6 do
-        it { is_expected.to be_a_multiple_of 3 }
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Configure rspec-expectations (explicitly)
-    Given a file named "example_spec.rb" with:
-      """ruby
-      RSpec.configure do |config|
-        config.expect_with :rspec
-      end
-
-      describe 5 do
-        it "is greater than 4" do
-          5.should be > 4
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass
-
-  @deprecated
-  Scenario: Configure 'stdlib' assertions
-    Given a file named "example_spec.rb" with:
-      """ruby
-      RSpec.configure do |config|
-        config.expect_with :stdlib
-      end
-
-      describe 5 do
-        it "is greater than 4" do
-          assert 5 > 4, "expected 5 to be greater than 4"
-        end
-
-        specify { assert 5 < 6 }
-
-        it "is greater than 6 (no it isn't!)" do
-          assert 5 > 6, "errantly expected 5 to be greater than 5"
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should match:
-      """
-           (Test::Unit::AssertionFailedError|Mini(T|t)est::Assertion):
-             errantly expected 5 to be greater than 5
-      """
-    And  the output should contain "3 examples, 1 failure"
-    And  the output should contain ":stdlib is deprecated. Use :test_unit or :minitest instead"
-
-  Scenario: Configure test/unit assertions
-    Given a file named "example_spec.rb" with:
-      """ruby
-      RSpec.configure do |config|
-        config.expect_with :test_unit
-      end
-
-      RSpec.describe [1] do
-        it "is equal to [1]" do
-          assert_equal [1], [1], "expected [1] to equal [1]"
-        end
-
-        specify { assert_not_equal [1], [] }
-
-        it "is equal to [2] (intentional failure)" do
-          assert [1] == [2], "errantly expected [2] to equal [1]"
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should match:
-      """
-           (Test::Unit::AssertionFailedError|Mini(T|t)est::Assertion):
-             errantly expected \[2\] to equal \[1\]
-      """
-    And  the output should contain "3 examples, 1 failure"
-
-  Scenario: Configure minitest assertions
-    Given a file named "example_spec.rb" with:
-      """ruby
-      RSpec.configure do |config|
-        config.expect_with :minitest
-      end
-
-      RSpec.describe "Object identity" do
-        it "the an object is the same as itself" do
-          x = [1]
-          assert_same x, x, "expected x to be the same x"
-        end
-
-        specify { refute_same [1], [1] }
-
-        it "is empty (intentional failure)" do
-          assert_empty [1], "errantly expected [1] to be empty"
-        end
-      end
-      """
-    When I run `rspec -b example_spec.rb`
-    Then the output should match:
-      """
-           MiniT|test::Assertion:
-             errantly expected \[1\] to be empty
-      """
-    And  the output should contain "3 examples, 1 failure"
-    And  the output should not contain "Warning: you should require 'minitest/autorun' instead."
-
-  Scenario: Configure rspec/expectations AND test/unit assertions
-    Given a file named "example_spec.rb" with:
-      """ruby
-      RSpec.configure do |config|
-        config.expect_with :rspec, :test_unit
-      end
-
-      RSpec.describe [1] do
-        it "is equal to [1]" do
-          assert_equal [1], [1], "expected [1] to equal [1]"
-        end
-
-        it "matches array [1]" do
-          is_expected.to match_array([1])
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Configure rspec/expecations AND minitest assertions
-    Given a file named "example_spec.rb" with:
-      """ruby
-      RSpec.configure do |config|
-        config.expect_with :rspec, :minitest
-      end
-
-      RSpec.describe "Object identity" do
-        it "two arrays are not the same object" do
-          refute_same [1], [1]
-        end
-
-        it "an array is itself" do
-          array = [1]
-          expect(array).to be array
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Configure test/unit and minitest assertions
-    Given a file named "example_spec.rb" with:
-      """ruby
-      RSpec.configure do |config|
-        config.expect_with :test_unit, :minitest
-      end
-
-      RSpec.describe [1] do
-        it "is equal to [1]" do
-          assert_equal [1], [1], "expected [1] to equal [1]"
-        end
-
-        specify { assert_not_equal [1], [] }
-
-        it "the an object is the same as itself" do
-          x = [1]
-          assert_same x, x, "expected x to be the same x"
-        end
-
-        specify { refute_same [1], [1] }
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass

data/features/filtering/exclusion_filters.feature

@@ -1,138 +0,0 @@
-Feature: exclusion filters
-
-  You can exclude examples from a run by declaring an exclusion filter and
-  then tagging examples, or entire groups, with that filter.
-
-  If you set the `treat_symbols_as_metadata_keys_with_true_values` config option
-  to `true`, you can specify metadata using only symbols.
-
-  Scenario: exclude an example
-    Given a file named "spec/sample_spec.rb" with:
-      """ruby
-      RSpec.configure do |c|
-        # declare an exclusion filter
-        c.filter_run_excluding :broken => true
-      end
-
-      describe "something" do
-        it "does one thing" do
-        end
-
-        # tag example for exclusion by adding metadata
-        it "does another thing", :broken => true do
-        end
-      end
-      """
-    When I run `rspec ./spec/sample_spec.rb --format doc`
-    Then the output should contain "does one thing"
-    And the output should not contain "does another thing"
-
-  Scenario: exclude a group
-    Given a file named "spec/sample_spec.rb" with:
-      """ruby
-      RSpec.configure do |c|
-        c.filter_run_excluding :broken => true
-      end
-
-      describe "group 1", :broken => true do
-        it "group 1 example 1" do
-        end
-
-        it "group 1 example 2" do
-        end
-      end
-
-      describe "group 2" do
-        it "group 2 example 1" do
-        end
-      end
-      """
-    When I run `rspec ./spec/sample_spec.rb --format doc`
-    Then the output should contain "group 2 example 1"
-    And  the output should not contain "group 1 example 1"
-    And  the output should not contain "group 1 example 2"
-
-  Scenario: exclude multiple groups
-    Given a file named "spec/sample_spec.rb" with:
-      """ruby
-      RSpec.configure do |c|
-        c.filter_run_excluding :broken => true
-      end
-
-      describe "group 1", :broken => true do
-        before(:all) do
-          raise "you should not see me"
-        end
-
-        it "group 1 example 1" do
-        end
-
-        it "group 1 example 2" do
-        end
-      end
-
-      describe "group 2", :broken => true do
-        before(:each) do
-          raise "you should not see me"
-        end
-
-        it "group 2 example 1" do
-        end
-      end
-      """
-    When I run `rspec ./spec/sample_spec.rb --format doc`
-    Then the process should succeed even though no examples were run
-    And  the output should not contain "group 1"
-    And  the output should not contain "group 2"
-
-  Scenario: before/after(:all) hooks in excluded example group are not run
-    Given a file named "spec/before_after_all_exclusion_filter_spec.rb" with:
-      """ruby
-      RSpec.configure do |c|
-        c.filter_run_excluding :broken => true
-      end
-
-      describe "group 1" do
-        before(:all) { puts "before all in included group" }
-        after(:all)  { puts "after all in included group"  }
-
-        it "group 1 example" do
-        end
-      end
-
-      describe "group 2", :broken => true do
-        before(:all) { puts "before all in excluded group" }
-        after(:all)  { puts "after all in excluded group"  }
-
-        context "context 1" do
-          it "group 2 context 1 example 1" do
-          end
-        end
-      end
-      """
-    When I run `rspec ./spec/before_after_all_exclusion_filter_spec.rb`
-    Then the output should contain "before all in included group"
-     And the output should contain "after all in included group"
-     And the output should not contain "before all in excluded group"
-     And the output should not contain "after all in excluded group"
-
-  Scenario: Use symbols as metadata
-    Given a file named "symbols_as_metadata_spec.rb" with:
-      """ruby
-      RSpec.configure do |c|
-        c.treat_symbols_as_metadata_keys_with_true_values = true
-        c.filter_run_excluding :broken
-      end
-
-      describe "something" do
-        it "does one thing" do
-        end
-
-        # tag example for exclusion by adding metadata
-        it "does another thing", :broken do
-        end
-      end
-      """
-    When I run `rspec symbols_as_metadata_spec.rb --format doc`
-    Then the output should contain "does one thing"
-    And the output should not contain "does another thing"