rspec-core 2.99.0 → 3.0.0

data/features/filtering/if_and_unless.feature

@@ -1,168 +0,0 @@
-Feature: :if and :unless
-
-  The `:if` and `:unless` metadata keys can be used to filter examples without
-  needing to configure an exclusion filter.
-
-  Scenario: implicit :if filter
-    Given a file named "implicit_if_filter_spec.rb" with:
-      """ruby
-      describe ":if => true group", :if => true do
-        it(":if => true group :if => true example", :if => true) { }
-        it(":if => true group :if => false example", :if => false) { }
-        it(":if => true group no :if example") { }
-      end
-
-      describe ":if => false group", :if => false do
-        it(":if => false group :if => true example", :if => true) { }
-        it(":if => false group :if => false example", :if => false) { }
-        it(":if => false group no :if example") { }
-      end
-
-      describe "no :if group" do
-        it("no :if group :if => true example", :if => true) { }
-        it("no :if group :if => false example", :if => false) { }
-        it("no :if group no :if example") { }
-      end
-      """
-    When I run `rspec implicit_if_filter_spec.rb --format doc`
-    Then the output should contain all of these:
-      | :if => true group :if => true example  |
-      | :if => true group no :if example       |
-      | :if => false group :if => true example |
-      | no :if group :if => true example       |
-      | no :if group no :if example            |
-    And the output should not contain any of these:
-      | :if => true group :if => false example  |
-      | :if => false group :if => false example |
-      | :if => false group no :if example       |
-      | no :if group :if => false example       |
-
-  Scenario: implicit :unless filter
-    Given a file named "implicit_unless_filter_spec.rb" with:
-      """ruby
-      describe ":unless => true group", :unless => true do
-        it(":unless => true group :unless => true example", :unless => true) { }
-        it(":unless => true group :unless => false example", :unless => false) { }
-        it(":unless => true group no :unless example") { }
-      end
-
-      describe ":unless => false group", :unless => false do
-        it(":unless => false group :unless => true example", :unless => true) { }
-        it(":unless => false group :unless => false example", :unless => false) { }
-        it(":unless => false group no :unless example") { }
-      end
-
-      describe "no :unless group" do
-        it("no :unless group :unless => true example", :unless => true) { }
-        it("no :unless group :unless => false example", :unless => false) { }
-        it("no :unless group no :unless example") { }
-      end
-      """
-    When I run `rspec implicit_unless_filter_spec.rb --format doc`
-    Then the output should contain all of these:
-      | :unless => true group :unless => false example  |
-      | :unless => false group :unless => false example |
-      | :unless => false group no :unless example       |
-      | no :unless group :unless => false example       |
-      | no :unless group no :unless example             |
-    And the output should not contain any of these:
-      | :unless => true group :unless => true example  |
-      | :unless => true group no :unless example       |
-      | :unless => false group :unless => true example |
-      | no :unless group :unless => true example       |
-
-  Scenario: combining implicit filter with explicit inclusion filter
-    Given a file named "explicit_inclusion_filter_spec.rb" with:
-      """ruby
-      RSpec.configure do |c|
-        c.filter_run :focus => true
-      end
-
-      describe "group with :focus", :focus => true do
-        it("focused example") { }
-        it("focused :if => true example", :if => true) { }
-        it("focused :if => false example", :if => false) { }
-        it("focused :unless => true example", :unless => true) { }
-        it("focused :unless => false example", :unless => false) { }
-      end
-
-      describe "group without :focus" do
-        it("unfocused example") { }
-        it("unfocused :if => true example", :if => true) { }
-        it("unfocused :if => false example", :if => false) { }
-        it("unfocused :unless => true example", :unless => true) { }
-        it("unfocused :unless => false example", :unless => false) { }
-      end
-      """
-    When I run `rspec explicit_inclusion_filter_spec.rb --format doc`
-    Then the output should contain all of these:
-      | focused example                  |
-      | focused :if => true example      |
-      | focused :unless => false example |
-    And the output should not contain any of these:
-      | focused :if => false example     |
-      | focused :unless => true example  |
-      | unfocused                        |
-
-  Scenario: combining implicit filter with explicit exclusion filter
-    Given a file named "explicit_exclusion_filter_spec.rb" with:
-      """ruby
-      RSpec.configure do |c|
-        c.filter_run_excluding :broken => true
-      end
-
-      describe "unbroken group" do
-        it("included example") { }
-        it("included :if => true example", :if => true) { }
-        it("included :if => false example", :if => false) { }
-        it("included :unless => true example", :unless => true) { }
-        it("included :unless => false example", :unless => false) { }
-      end
-
-      describe "broken group", :broken => true do
-        it("excluded example") { }
-        it("excluded :if => true example", :if => true) { }
-        it("excluded :if => false example", :if => false) { }
-        it("excluded :unless => true example", :unless => true) { }
-        it("excluded :unless => false example", :unless => false) { }
-      end
-      """
-    When I run `rspec explicit_exclusion_filter_spec.rb --format doc`
-    Then the output should contain all of these:
-      | included example                  |
-      | included :if => true example      |
-      | included :unless => false example |
-    And the output should not contain any of these:
-      | included :if => false example     |
-      | included :unless => true example  |
-      | excluded                          |
-
-  Scenario: override implicit :if and :unless exclusion filters
-    Given a file named "override_implicit_filters_spec.rb" with:
-      """ruby
-      RSpec.configure do |c|
-        c.filter_run_excluding :if => :exclude_me, :unless => :exclude_me_for_unless
-      end
-
-      describe ":if filtering" do
-        it(":if => true example", :if => true) { }
-        it(":if => false example", :if => false) { }
-        it(":if => :exclude_me example", :if => :exclude_me) { }
-      end
-
-      describe ":unless filtering" do
-        it(":unless => true example", :unless => true) { }
-        it(":unless => false example", :unless => false) { }
-        it(":unless => :exclude_me_for_unless example", :unless => :exclude_me_for_unless) { }
-      end
-      """
-    When I run `rspec override_implicit_filters_spec.rb --format doc`
-    Then the output should contain all of these:
-      | :if => true example      |
-      | :if => false example     |
-      | :unless => true example  |
-      | :unless => false example |
-    And the output should not contain any of these:
-      | :if => :exclude_me example                |
-      | :unless => :exclude_me_for_unless example |
-

data/features/filtering/inclusion_filters.feature

@@ -1,105 +0,0 @@
-Feature: inclusion filters
-
-  You can constrain which examples are run by declaring an inclusion filter. The
-  most common use case is to focus on a subset of examples as you're focused on
-  a particular problem.
-
-  You can specify metadata using only symbols if you set the
-  `treat_symbols_as_metadata_keys_with_true_values` config option to `true`.
-
-  Background:
-    Given a file named "spec/spec_helper.rb" with:
-      """ruby
-      RSpec.configure do |c|
-        c.filter_run_including :focus => true
-      end
-      """
-
-  Scenario: focus on an example
-    Given a file named "spec/sample_spec.rb" with:
-      """ruby
-      require "spec_helper"
-
-      describe "something" do
-        it "does one thing" do
-        end
-
-        it "does another thing", :focus => true do
-        end
-      end
-      """
-    When I run `rspec spec/sample_spec.rb --format doc`
-    Then the output should contain "does another thing"
-    And the output should not contain "does one thing"
-
-  Scenario: focus on a group
-    Given a file named "spec/sample_spec.rb" with:
-      """ruby
-      require "spec_helper"
-
-      describe "group 1", :focus => 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 1 example 1"
-    And  the output should contain "group 1 example 2"
-    And  the output should not contain "group 2 example 1"
-
-  Scenario: before/after(:all) hooks in unmatched example group are not run
-    Given a file named "spec/before_after_all_inclusion_filter_spec.rb" with:
-      """ruby
-      require "spec_helper"
-
-      describe "group 1", :focus => true do
-        before(:all) { puts "before all in focused group" }
-        after(:all)  { puts "after all in focused group"  }
-
-        it "group 1 example" do
-        end
-      end
-
-      describe "group 2" do
-        before(:all) { puts "before all in unfocused group" }
-        after(:all)  { puts "after all in unfocused group"  }
-
-        context "context 1" do
-          it "group 2 context 1 example 1" do
-          end
-        end
-      end
-      """
-    When I run `rspec ./spec/before_after_all_inclusion_filter_spec.rb`
-    Then the output should contain "before all in focused group"
-     And the output should contain "after all in focused group"
-     And the output should not contain "before all in unfocused group"
-     And the output should not contain "after all in unfocused 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 :current_example
-      end
-
-      describe "something" do
-        it "does one thing" do
-        end
-
-        it "does another thing", :current_example do
-        end
-      end
-      """
-    When I run `rspec symbols_as_metadata_spec.rb --format doc`
-    Then the output should contain "does another thing"
-    And the output should not contain "does one thing"

data/features/formatters/configurable_colors.feature

@@ -1,31 +0,0 @@
-Feature: Configurable colors
-
-  RSpec allows you to configure the terminal colors used in the text formatters.
-
-  * `failure_color`: Color used when tests fail (default: `:red`)
-  * `success_color`: Color used when tests pass (default: `:green`)
-  * `pending_color`: Color used when tests are pending (default: `:yellow`)
-  * `fixed_color`: Color used when a pending block inside an example passes, but was expected to fail (default: `:blue`)
-  * `detail_color`: Color used for miscellaneous test details (default: `:cyan`)
-
-  Colors are normally specified as symbols. Options are `:black`, `:red`,
-  `:green`, `:yellow`, `:blue`, `:magenta`, `:cyan`, and `:white`.
-
-  @ansi
-  Scenario: Customizing the failure color
-    Given a file named "custom_failure_color_spec.rb" with:
-      """ruby
-      RSpec.configure do |config|
-        config.failure_color = :magenta
-        config.tty = true
-        config.color = true
-      end
-
-      describe "failure" do
-        it "fails and uses the custom color" do
-          expect(2).to eq(4)
-        end
-      end
-      """
-      When I run `rspec custom_failure_color_spec.rb --format progress`
-      Then the failing example is printed in magenta

data/features/formatters/custom_formatter.feature

@@ -1,36 +0,0 @@
-Feature: custom formatters
-
-  RSpec ships with general purpose output formatters. You can tell RSpec which
-  one to use using the [`--format` command line
-  option]('../command_line/format_option').
-
-  When RSpec's built-in output formatters don't, however, give you everything
-  you need, you can write your own custom formatter and tell RSpec to use that
-  one instead.  The simplest way is to subclass RSpec's `BaseTextFormatter`,
-  and then override just the methods that you want to modify.
-
-  Scenario: custom formatter
-    Given a file named "custom_formatter.rb" with:
-      """ruby
-      require "rspec/core/formatters/base_text_formatter"
-
-      class CustomFormatter < RSpec::Core::Formatters::BaseTextFormatter
-        def initialize(output)
-          super(output)
-        end
-
-        def example_started(proxy)
-          output << "example: " << proxy.description
-        end
-      end
-      """
-    And a file named "example_spec.rb" with:
-      """ruby
-      describe "my group" do
-        specify "my example" do
-        end
-      end
-      """
-    When I run `rspec example_spec.rb --require ./custom_formatter.rb --format CustomFormatter`
-    Then the output should contain "example: my example"
-    And  the exit status should be 0

data/features/formatters/json_formatter.feature

@@ -1,30 +0,0 @@
-Feature: JSON formatter
-
-  Scenario: Formatting example names for retry
-    Given a file named "various_spec.rb" with:
-    """ruby
-    describe "Various" do
-      it "fails" do
-        "fail".should eq("succeed")
-      end
-
-      it "succeeds" do
-        "succeed".should eq("succeed")
-      end
-
-      it "pends"
-    end
-    """
-    When I run `rspec various_spec.rb --format j`
-    Then the output should contain all of these:
-          |"summary_line":"3 examples, 1 failure, 1 pending"|
-          |"examples":[                                     |
-          |"description":"fails"                             |
-          |"full_description":"Various fails"                |
-          |"status":"failed"                                 |
-          |"file_path":"./various_spec.rb"                   |
-          |"line_number":2                                   |
-          |"exception":{                                     |
-          |"class":"RSpec::Expectations::ExpectationNotMetError"|
-
-    And the exit status should be 1

data/features/formatters/text_formatter.feature

@@ -1,46 +0,0 @@
-Feature: text formatter
-
-  In order to easily see the result of running my specs
-  As an RSpec user
-  I want clear, concise, well-formatted output
-
-  Scenario: Backtrace formatting for failing specs in multiple files
-    Given a file named "string_spec.rb" with:
-      """ruby
-      describe String do
-        it "has a failing example" do
-          "foo".reverse.should eq("ofo")
-        end
-      end
-      """
-    And a file named "integer_spec.rb" with:
-      """ruby
-      describe Integer do
-        it "has a failing example" do
-          (7 + 5).should eq(11)
-        end
-      end
-      """
-    When I run `rspec integer_spec.rb string_spec.rb`
-    Then the backtrace-normalized output should contain:
-      """
-        1) Integer has a failing example
-           Failure/Error: (7 + 5).should eq(11)
-             
-             expected: 11
-                  got: 12
-             
-             (compared using ==)
-           # ./integer_spec.rb:3
-      """
-    And the backtrace-normalized output should contain:
-      """
-        2) String has a failing example
-           Failure/Error: "foo".reverse.should eq("ofo")
-             
-             expected: "ofo"
-                  got: "oof"
-             
-             (compared using ==)
-           # ./string_spec.rb:3
-      """

data/features/helper_methods/arbitrary_methods.feature

@@ -1,40 +0,0 @@
-Feature: arbitrary helper methods
-
-  You can define methods in any example group using Ruby's `def` keyword or
-  `define_method` method. These _helper_ methods are exposed to examples in the
-  group in which they are defined and groups nested within that group, but not
-  parent or sibling groups.
-
-  Scenario: use a method defined in the same group
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "an example" do
-        def help
-          :available
-        end
-
-        it "has access to methods defined in its group" do
-          help.should be(:available)
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass
-
-  Scenario: use a method defined in a parent group
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "an example" do
-        def help
-          :available
-        end
-
-        describe "in a nested group" do
-          it "has access to methods defined in its parent group" do
-            help.should be(:available)
-          end
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass

data/features/helper_methods/let.feature

@@ -1,50 +0,0 @@
-Feature: let and let!
-
-  Use `let` to define a memoized helper method.  The value will be cached
-  across multiple calls in the same example but not across examples.
-
-  Note that `let` is lazy-evaluated: it is not evaluated until the first time
-  the method it defines is invoked. You can use `let!` to force the method's
-  invocation before each example.
-
-  Scenario: use let to define memoized helper method
-    Given a file named "let_spec.rb" with:
-      """ruby
-      $count = 0
-      describe "let" do
-        let(:count) { $count += 1 }
-
-        it "memoizes the value" do
-          count.should eq(1)
-          count.should eq(1)
-        end
-
-        it "is not cached across examples" do
-          count.should eq(2)
-        end
-      end
-      """
-    When I run `rspec let_spec.rb`
-    Then the examples should all pass
-
-  Scenario: use let! to define a memoized helper method that is called in a before hook
-    Given a file named "let_bang_spec.rb" with:
-      """ruby
-      $count = 0
-      describe "let!" do
-        invocation_order = []
-
-        let!(:count) do
-          invocation_order << :let!
-          $count += 1
-        end
-
-        it "calls the helper method in a before hook" do
-          invocation_order << :example
-          invocation_order.should == [:let!, :example]
-          count.should eq(1)
-        end
-      end
-      """
-    When I run `rspec let_bang_spec.rb`
-    Then the examples should all pass

data/features/helper_methods/modules.feature

@@ -1,149 +0,0 @@
-Feature: Define helper methods in a module
-
-  You can define helper methods in a module and include it in
-  your example groups using the `config.include` configuration
-  option.  `config.extend` can be used to extend the module onto
-  your example groups so that the methods in the module are available
-  in the example groups themselves (but not in the actual examples).
-
-  You can also include or extend the module onto only certain example
-  groups by passing a metadata hash as the last argument.  Only groups
-  that match the given metadata will include or extend the module.
-
-  If you set the `treat_symbols_as_metadata_keys_with_true_values` config option
-  to `true`, you can specify metadata using only symbols.
-
-  Background:
-    Given a file named "helpers.rb" with:
-      """ruby
-      module Helpers
-        def help
-          :available
-        end
-      end
-      """
-
-  Scenario: include a module in all example groups
-    Given a file named "include_module_spec.rb" with:
-      """ruby
-      require './helpers'
-
-      RSpec.configure do |c|
-        c.include Helpers
-      end
-
-      describe "an example group" do
-        it "has access to the helper methods defined in the module" do
-          help.should be(:available)
-        end
-      end
-      """
-    When I run `rspec include_module_spec.rb`
-    Then the examples should all pass
-
-  Scenario: extend a module in all example groups
-    Given a file named "extend_module_spec.rb" with:
-      """ruby
-      require './helpers'
-
-      RSpec.configure do |c|
-        c.extend Helpers
-      end
-
-      describe "an example group" do
-        puts "Help is #{help}"
-
-        it "does not have access to the helper methods defined in the module" do
-          expect { help }.to raise_error(NameError)
-        end
-      end
-      """
-    When I run `rspec extend_module_spec.rb`
-    Then the examples should all pass
-    And the output should contain "Help is available"
-
-  Scenario: include a module in only some example groups
-    Given a file named "include_module_in_some_groups_spec.rb" with:
-      """ruby
-      require './helpers'
-
-      RSpec.configure do |c|
-        c.include Helpers, :foo => :bar
-      end
-
-      describe "an example group with matching metadata", :foo => :bar do
-        it "has access to the helper methods defined in the module" do
-          help.should be(:available)
-        end
-      end
-
-      describe "an example group without matching metadata" do
-        it "does not have access to the helper methods defined in the module" do
-          expect { help }.to raise_error(NameError)
-        end
-      end
-      """
-    When I run `rspec include_module_in_some_groups_spec.rb`
-    Then the examples should all pass
-
-  Scenario: extend a module in only some example groups
-    Given a file named "extend_module_in_only_some_groups_spec.rb" with:
-      """ruby
-      require './helpers'
-
-      RSpec.configure do |c|
-        c.extend Helpers, :foo => :bar
-      end
-
-      describe "an example group with matching metadata", :foo => :bar do
-        puts "In a matching group, help is #{help}"
-
-        it "does not have access to the helper methods defined in the module" do
-          expect { help }.to raise_error(NameError)
-        end
-      end
-
-      describe "an example group without matching metadata" do
-        puts "In a non-matching group, help is #{help rescue 'not available'}"
-
-        it "does not have access to the helper methods defined in the module" do
-          expect { help }.to raise_error(NameError)
-        end
-      end
-      """
-    When I run `rspec extend_module_in_only_some_groups_spec.rb`
-    Then the examples should all pass
-    And the output should contain "In a matching group, help is available"
-    And the output should contain "In a non-matching group, help is not available"
-
-  Scenario: use symbols as metadata
-    Given a file named "symbols_as_metadata_spec.rb" with:
-      """ruby
-      require './helpers'
-
-      RSpec.configure do |c|
-        c.treat_symbols_as_metadata_keys_with_true_values = true
-        c.include Helpers, :include_helpers
-        c.extend  Helpers, :extend_helpers
-      end
-
-      describe "an example group with matching include metadata", :include_helpers do
-        puts "In a group not matching the extend filter, help is #{help rescue 'not available'}"
-
-        it "has access to the helper methods defined in the module" do
-          help.should be(:available)
-        end
-      end
-
-      describe "an example group with matching extend metadata", :extend_helpers do
-        puts "In a group matching the extend filter, help is #{help}"
-
-        it "does not have access to the helper methods defined in the module" do
-          expect { help }.to raise_error(NameError)
-        end
-      end
-      """
-    When I run `rspec symbols_as_metadata_spec.rb`
-    Then the examples should all pass
-    And the output should contain "In a group not matching the extend filter, help is not available"
-    And the output should contain "In a group matching the extend filter, help is available"