rspec-core 3.0.0.beta2 → 3.0.0.rc1

data/features/configuration/run_all_when_everything_filtered.feature

@@ -1,76 +0,0 @@
-Feature: run all when everything filtered
-
-  Use the run_all_when_everything_filtered option to tell RSpec to run all the
-  specs in the case where you try to run a filtered list of specs but no specs
-  match that filter. This works well when paired with an inclusion filter like
-  `:focus => true`, as it will run all the examples when none match the
-  inclusion filter.
-
-    RSpec.configure { |c| c.run_all_when_everything_filtered = true }
-
-  Background:
-    Given a file named "spec/spec_helper.rb" with:
-      """ruby
-      RSpec.configure {|c| c.run_all_when_everything_filtered = true}
-      """
-
-  Scenario: by default, no specs are run if they are all filtered out by an inclusion tag
-    Given a file named "spec/example_spec.rb" with:
-      """ruby
-      describe "examples" do
-        it "with no tag" do
-        end
-
-        it "with no tag as well" do
-        end
-      end
-      """
-    When I run `rspec spec/example_spec.rb --tag some_tag`
-    Then the output should contain "0 examples, 0 failures"
-
-  Scenario: specs are still run if they are filtered out by an exclusion tag
-    Given a file named "spec/example_spec.rb" with:
-      """ruby
-      describe "examples" do
-        it "with no tag" do
-        end
-
-        it "with no tag as well" do
-        end
-      end
-      """
-    When I run `rspec spec/example_spec.rb --tag ~some_tag`
-    Then the output should contain "2 examples, 0 failures"
-
-  Scenario: when the run_all_when_everything_filtered option is turned on, if there are any matches for the filtering tag, only those features are run
-    Given a file named "spec/example_spec.rb" with:
-      """ruby
-      require "spec_helper"
-      describe "examples" do
-        it "with no tag", :some_tag => true do
-        end
-
-        it "with no tag as well" do
-        end
-      end
-      """
-    When I run `rspec spec/example_spec.rb --tag some_tag`
-    Then the output should contain "1 example, 0 failures"
-    And the output should contain "Run options: include {:some_tag=>true}"
-
-  Scenario: when the run_all_when_everything_filtered option is turned on, all the specs are run when the tag has no matches
-    Given a file named "spec/example_spec.rb" with:
-      """ruby
-      require "spec_helper"
-      describe "examples" do
-        it "with no tag" do
-        end
-
-        it "with no tag as well" do
-        end
-      end
-      """
-    When I run `rspec spec/example_spec.rb --tag some_tag`
-    Then the output should contain "2 examples, 0 failures"
-    And the output should contain "All examples were filtered out; ignoring {:some_tag=>true}"
-

data/features/example_groups/aliasing.feature

@@ -1,48 +0,0 @@
-Feature: aliasing
-
-  `describe` and `context` are the default aliases for `example_group`.
-  You can define your own aliases for `example_group` and give those
-  custom aliases default metadata.
-
-  RSpec provides a few built-in aliases:
-
-    * `xdescribe` and `xcontext` add `:pending` metadata to the
-      example group in order to temporarily disable the examples.
-    * `fdescribe` and `fcontext` add `:focus` metadata to the
-      example group in order to make it easy to temporarily
-      focus the example group (when combined with `config.filter_run :focus`.)
-
-  Scenario: custom example group aliases with metadata
-    Given a file named "nested_example_group_aliases_spec.rb" with:
-    """ruby
-    RSpec.configure do |c|
-      c.alias_example_group_to :detail, :detailed => true
-    end
-
-    RSpec.detail "a detail" do
-      it "can do some less important stuff" do
-      end
-    end
-
-    RSpec.describe "a thing" do
-      describe "in broad strokes" do
-        it "can do things" do
-        end
-      end
-
-      detail "something less important" do
-        it "can do an unimportant thing" do
-        end
-      end
-    end
-    """
-    When I run `rspec nested_example_group_aliases_spec.rb --tag detailed -fdoc`
-    Then the output should contain:
-      """
-      a detail
-        can do some less important stuff
-
-      a thing
-        something less important
-      """
-

data/features/example_groups/basic_structure.feature

@@ -1,55 +0,0 @@
-Feature: basic structure (describe/it)
-
-  RSpec is a DSL for creating executable examples of how code is expected to
-  behave, organized in groups. It uses the words "describe" and "it" so we can
-  express concepts like a conversation:
-
-      "Describe an account when it is first opened."
-      "It has a balance of zero."
-
-  The `describe` method creates an example group.  Within the block passed to
-  `describe` you can declare nested groups using the `describe` or `context`
-  methods, or you can declare examples using the `it` or `specify` methods.
-
-  Under the hood, an example group is a class in which the block passed to
-  `describe` or `context` is evaluated. The blocks passed to `it` are evaluated
-  in the context of an _instance_ of that class.
-
-  Scenario: one group, one example
-    Given a file named "sample_spec.rb" with:
-    """ruby
-    describe "something" do
-      it "does something" do
-      end
-    end
-    """
-    When I run `rspec sample_spec.rb -fdoc`
-    Then the output should contain:
-      """
-      something
-        does something
-      """
-
-  Scenario: nested example groups (using context)
-    Given a file named "nested_example_groups_spec.rb" with:
-    """ruby
-    describe "something" do
-      context "in one context" do
-        it "does one thing" do
-        end
-      end
-      context "in another context" do
-        it "does another thing" do
-        end
-      end
-    end
-    """
-    When I run `rspec nested_example_groups_spec.rb -fdoc`
-    Then the output should contain:
-      """
-      something
-        in one context
-          does one thing
-        in another context
-          does another thing
-      """

data/features/example_groups/shared_context.feature

@@ -1,74 +0,0 @@
-Feature: shared context
-
-  Use `shared_context` to define a block that will be evaluated in the context
-  of example groups either explicitly, using `include_context`, or implicitly by
-  matching metadata.
-
-  Background:
-    Given a file named "shared_stuff.rb" with:
-      """ruby
-      shared_context "shared stuff", :a => :b do
-        before { @some_var = :some_value }
-        def shared_method
-          "it works"
-        end
-        let(:shared_let) { {'arbitrary' => 'object'} }
-        subject do
-          'this is the subject'
-        end
-      end
-      """
-
-  Scenario: declare shared context and include it with include_context
-    Given a file named "shared_context_example.rb" with:
-      """ruby
-      require "./shared_stuff.rb"
-
-      describe "group that includes a shared context using 'include_context'" do
-        include_context "shared stuff"
-
-        it "has access to methods defined in shared context" do
-          expect(shared_method).to eq("it works")
-        end
-
-        it "has access to methods defined with let in shared context" do
-          expect(shared_let['arbitrary']).to eq('object')
-        end
-
-        it "runs the before hooks defined in the shared context" do
-          expect(@some_var).to be(:some_value)
-        end
-
-        it "accesses the subject defined in the shared context" do
-          expect(subject).to eq('this is the subject')
-        end
-      end
-      """
-    When I run `rspec shared_context_example.rb`
-    Then the examples should all pass
-
-  Scenario: declare shared context and include it with metadata
-    Given a file named "shared_context_example.rb" with:
-      """ruby
-      require "./shared_stuff.rb"
-
-      describe "group that includes a shared context using metadata", :a => :b do
-        it "has access to methods defined in shared context" do
-          expect(shared_method).to eq("it works")
-        end
-
-        it "has access to methods defined with let in shared context" do
-          expect(shared_let['arbitrary']).to eq('object')
-        end
-
-        it "runs the before hooks defined in the shared context" do
-          expect(@some_var).to be(:some_value)
-        end
-
-        it "accesses the subject defined in the shared context" do
-          expect(subject).to eq('this is the subject')
-        end
-      end
-      """
-    When I run `rspec shared_context_example.rb`
-    Then the examples should all pass

data/features/example_groups/shared_examples.feature

@@ -1,286 +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
-            expect(collection.size).to eq(3)
-          end
-        end
-
-        describe "#include?" do
-          context "with an an item that is in the collection" do
-            it "returns true" do
-              expect(collection.include?(7)).to be_truthy
-            end
-          end
-
-          context "with an an item that is not in the collection" do
-            it "returns false" do
-              expect(collection.include?(9)).to 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
-          expect(subject.send(measurement_method)).to eq(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
-          expect(sortable).to 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:
-      """
-      Could not find shared examples \"shared examples are isolated\"
-      """