opal-rspec 0.8.0 → 1.0.0

data/rspec-core/upstream/features/filtering/filter_run_when_matching.feature

@@ -0,0 +1,75 @@
+Feature: filter_run_when_matching
+
+  You can configure a _conditional_ filter that only applies if there are any matching
+  examples using `config.filter_run_when_matching`. This is commonly used for focus
+  filtering:
+
+  ```ruby
+  RSpec.configure do |c|
+    c.filter_run_when_matching :focus
+  end
+  ```
+
+  This configuration allows you to filter to specific examples or groups by tagging
+  them with `:focus` metadata. When no example or groups are focused (which should be
+  the norm since it's intended to be a temporary change), the filter will be ignored.
+
+  RSpec also provides aliases--`fit`, `fdescribe` and `fcontext`--as a shorthand for
+  `it`, `describe` and `context` with `:focus` metadata, making it easy to temporarily
+  focus an example or group by prefixing an `f`.
+
+  Background:
+    Given a file named "spec/spec_helper.rb" with:
+      """ruby
+      RSpec.configure do |c|
+        c.filter_run_when_matching :focus
+      end
+      """
+    And a file named ".rspec" with:
+      """
+      --require spec_helper
+      """
+    And a file named "spec/example_spec.rb" with:
+      """ruby
+      RSpec.describe "A group" do
+        it "has a passing example" do
+        end
+
+        context "a nested group" do
+          it "also has a passing example" do
+          end
+        end
+      end
+      """
+
+  Scenario: The filter is ignored when nothing is focused
+    When I run `rspec --format doc`
+    Then it should pass with "2 examples, 0 failures"
+    And the output should contain:
+      """
+      A group
+        has a passing example
+        a nested group
+          also has a passing example
+      """
+
+  Scenario: Examples can be focused with `fit`
+    Given I have changed `it "has a passing example"` to `fit "has a passing example"` in "spec/example_spec.rb"
+    When I run `rspec --format doc`
+    Then it should pass with "1 example, 0 failures"
+    And the output should contain:
+      """
+      A group
+        has a passing example
+      """
+
+  Scenario: Groups can be focused with `fdescribe` or `fcontext`
+    Given I have changed `context` to `fcontext` in "spec/example_spec.rb"
+    When I run `rspec --format doc`
+    Then it should pass with "1 example, 0 failures"
+    And the output should contain:
+      """
+      A group
+        a nested group
+          also has a passing example
+      """

data/rspec-core/upstream/features/formatters/configurable_colors.feature

@@ -10,16 +10,17 @@ Feature: Configurable colors
   * `detail_color`: Color used for miscellaneous test details (default: `:cyan`)
 
   Colors are specified as symbols. Options are `:black`, `:red`, `:green`,
-  `:yellow`, `:blue`, `:magenta`, `:cyan`, and `:white`.
+  `:yellow`, `:blue`, `:magenta`, `:cyan`, `:white`, `:bold_black`, `:bold_red`,
+  `:bold_green`, `:bold_yellow`, `:bold_blue`, `:bold_magenta`, `:bold_cyan`,
+  and `:bold_white`,
 
-  @ansi
+  @keep-ansi-escape-sequences
   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
+        config.color_mode = :on
       end
 
       RSpec.describe "failure" do
@@ -30,3 +31,21 @@ Feature: Configurable colors
       """
       When I run `rspec custom_failure_color_spec.rb --format progress`
       Then the failing example is printed in magenta
+
+  @keep-ansi-escape-sequences
+  Scenario: Customizing the failure color with a custom console code
+    Given a file named "custom_failure_color_spec.rb" with:
+      """ruby
+      RSpec.configure do |config|
+        config.failure_color = "1;32"
+        config.color_mode = :on
+      end
+
+      RSpec.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 wrapped in "1;32"

data/rspec-core/upstream/features/helper_methods/let.feature

@@ -7,6 +7,9 @@ Feature: let and let!
   the method it defines is invoked. You can use `let!` to force the method's
   invocation before each example.
 
+  By default, `let` is threadsafe, but you can configure it not to be
+  by disabling `config.threadsafe`, which makes `let` perform a bit faster.
+
   Scenario: Use `let` to define memoized helper method
     Given a file named "let_spec.rb" with:
       """ruby

data/rspec-core/upstream/features/helper_methods/modules.feature

@@ -11,6 +11,8 @@ Feature: Define helper methods in a module
   given metadata will `include` or `extend` the module. You can also specify
   metadata using only symbols.
 
+  Note that examples that match a `config.include` module's metadata will also have the module included. RSpec treats every example as having a singleton example group (analogous to Ruby's singleton classes) containing just the one example.
+
   Background:
     Given a file named "helpers.rb" with:
       """ruby
@@ -79,6 +81,10 @@ Feature: Define helper methods in a module
         it "does not have access to the helper methods defined in the module" do
           expect { help }.to raise_error(NameError)
         end
+
+        it "does have access when the example has matching metadata", :foo => :bar do
+          expect(help).to be(:available)
+        end
       end
       """
     When I run `rspec include_module_in_some_groups_spec.rb`

data/rspec-core/upstream/features/hooks/around_hooks.feature

@@ -17,6 +17,9 @@ Feature: `around` hooks
   **WARNING:** Mock frameworks are set up and torn down within the context of
   running the example. You cannot interact with them directly in `around` hooks.
 
+  **WARNING:** `around` hooks will execute *before* any `before` hooks, and *after*
+  any `after` hooks regardless of the context they were defined in.
+
   Scenario: Use the example as a proc within the block passed to `around()`
     Given a file named "example_spec.rb" with:
       """ruby
@@ -85,6 +88,29 @@ Feature: `around` hooks
     When I run `rspec example_spec.rb`
     Then the output should contain "this should show up in the output"
 
+  Scenario: An around hook continues to run even if the example throws an exception
+    Given a file named "example_spec.rb" with:
+      """ruby
+        RSpec.describe "something" do
+          around(:example) do |example|
+            puts "around example setup"
+            example.run
+            puts "around example cleanup"
+          end
+
+          it "still executes the entire around hook" do
+            fail "the example blows up"
+          end
+        end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain "1 example, 1 failure"
+    And the output should contain:
+      """
+      around example setup
+      around example cleanup
+      """
+
   Scenario: Define a global `around` hook
     Given a file named "example_spec.rb" with:
       """ruby
@@ -193,7 +219,7 @@ Feature: `around` hooks
         end
 
         it "runs the example in the correct context" do
-          expect(included_in_configure_block).to be_truthy
+          expect(included_in_configure_block).to be(true)
         end
       end
       """
@@ -215,9 +241,11 @@ Feature: `around` hooks
     Then the output should contain "1 example, 0 failures, 1 pending"
     And the output should contain:
       """
-      Pending:
-        implicit pending example should be detected as Not yet implemented
-          # Not yet implemented
+      Pending: (Failures listed here are expected and do not affect your suite's status)
+
+        1) implicit pending example should be detected as Not yet implemented
+           # Not yet implemented
+           # ./example_spec.rb:6
       """
 
 
@@ -239,8 +267,10 @@ Feature: `around` hooks
     Then the output should contain "1 example, 0 failures, 1 pending"
     And the output should contain:
       """
-        explicit pending example should be detected as pending
-          # No reason given
+      Pending: (Failures listed here are expected and do not affect your suite's status)
+
+        1) explicit pending example should be detected as pending
+           # No reason given
       """
 
   Scenario: Multiple `around` hooks in the same scope

data/rspec-core/upstream/features/hooks/before_and_after_hooks.feature

@@ -22,13 +22,19 @@ Feature: `before` and `after` hooks
   after  :suite
   ```
 
+  A bare `before` or `after` hook defaults to the `:example` scope.
+
   `before` and `after` hooks can be defined directly in the example groups they
-  should run in, or in a global `RSpec.configure` block.
+  should run in, or in a global `RSpec.configure` block. Note that the status of
+  the example does not affect the hooks.
 
   **WARNING:** Setting instance variables are not supported in `before(:suite)`.
 
   **WARNING:** Mocks are only supported in `before(:example)`.
 
+  **WARNING:** `around` hooks will execute *before* any `before` hooks, and *after*
+  any `after` hooks regardless of the context they were defined in.
+
   Note: the `:example` and `:context` scopes are also available as `:each` and
   `:all`, respectively. Use whichever you prefer.
 
@@ -174,11 +180,37 @@ Feature: `before` and `after` hooks
       end
       """
     When I run `rspec after_context_spec.rb`
-    Then the examples should all pass
-    And the output should contain:
+    Then it should fail with:
       """
       An error occurred in an `after(:context)` hook.
-        StandardError: Boom!
+      Failure/Error: raise StandardError.new("Boom!")
+
+      StandardError:
+        Boom!
+      # ./after_context_spec.rb:3
+      """
+
+  Scenario: A failure in an example does not affect hooks
+    Given a file named "failure_in_example_spec.rb" with:
+      """ruby
+      RSpec.describe "a failing example does not affect hooks" do
+        before(:context) { puts "before context runs" }
+        before(:example) { puts "before example runs" }
+        after(:example) { puts "after example runs" }
+        after(:context) { puts "after context runs" }
+
+        it "fails the example but runs the hooks" do
+          raise "An Error"
+        end
+      end
+      """
+    When I run `rspec failure_in_example_spec.rb`
+    Then it should fail with:
+      """
+      before context runs
+      before example runs
+      after example runs
+      Fafter context runs
       """
 
   Scenario: Define `before` and `after` blocks in configuration
@@ -225,10 +257,18 @@ Feature: `before` and `after` hooks
           puts "before example"
         end
 
+        before do
+          puts "also before example but by default"
+        end
+
         after(:example) do
           puts "after example"
         end
 
+        after do
+          puts "also after example but by default"
+        end
+
         after(:context) do
           puts "after context"
         end
@@ -243,11 +283,13 @@ Feature: `before` and `after` hooks
       """
       before context
       before example
+      also before example but by default
+      also after example but by default
       after example
       .after context
       """
 
-  Scenario: `before`/after` blocks defined in configuration are run in order
+  Scenario: `before`/`after` blocks defined in configuration are run in order
     Given a file named "configuration_spec.rb" with:
       """ruby
       require "rspec/expectations"

data/rspec-core/upstream/features/hooks/filtering.feature

@@ -14,6 +14,8 @@ Feature: filters
   end
   ```
 
+  Note that filtered `:context` hooks will still be applied to individual examples with matching metadata -- in effect, every example has a singleton example group containing just the one example (analogous to Ruby's singleton classes).
+
   You can also specify metadata using only symbols.
 
   Scenario: Filter `before(:example)` hooks using arbitrary metadata
@@ -127,6 +129,10 @@ Feature: filters
             expect(@hook).to be_nil
           end
 
+          it "runs the hook for a single example with matching metadata", :foo => :bar do
+            expect(@hook).to eq(:before_context_foo_bar)
+          end
+
           describe "a nested subgroup with matching metadata", :foo => :bar do
             it "runs the hook" do
               expect(@hook).to eq(:before_context_foo_bar)
@@ -166,31 +172,37 @@ Feature: filters
           it "does not run the hook" do
             puts "unfiltered"
           end
+
+          it "runs the hook for a single example with matching metadata", :foo => :bar do
+            puts "filtered 1"
+          end
         end
 
         describe "a group with matching metadata", :foo => :bar do
           it "runs the hook" do
-            puts "filtered 1"
+            puts "filtered 2"
           end
         end
 
         describe "another group without matching metadata" do
           describe "a nested subgroup with matching metadata", :foo => :bar do
             it "runs the hook" do
-              puts "filtered 2"
+              puts "filtered 3"
             end
           end
         end
       end
       """
-    When I run `rspec --format progress filter_after_context_hooks_spec.rb`
+    When I run `rspec --format progress filter_after_context_hooks_spec.rb --order defined`
     Then the examples should all pass
     And the output should contain:
       """
       unfiltered
       .filtered 1
+      after :context
+      .filtered 2
       .after :context
-      filtered 2
+      filtered 3
       .after :context
       """
 
@@ -232,3 +244,186 @@ Feature: filters
       .after context
       """
 
+  Scenario: Filtering hooks using symbols
+    Given a file named "filter_example_hooks_with_symbol_spec.rb" with:
+      """ruby
+      RSpec.configure do |config|
+        config.before(:example, :foo) do
+          invoked_hooks << :before_example_foo_bar
+        end
+      end
+
+      RSpec.describe "a filtered before :example hook" do
+        let(:invoked_hooks) { [] }
+
+        describe "group without a matching metadata key" do
+          it "does not run the hook" do
+            expect(invoked_hooks).to be_empty
+          end
+
+          it "does not run the hook for an example with metadata hash containing the key with a falsey value", :foo => nil do
+            expect(invoked_hooks).to be_empty
+          end
+
+          it "runs the hook for an example with metadata hash containing the key with a truthy value", :foo => :bar do
+            expect(invoked_hooks).to eq([:before_example_foo_bar])
+          end
+
+          it "runs the hook for an example with only the key defined", :foo do
+            expect(invoked_hooks).to eq([:before_example_foo_bar])
+          end
+        end
+
+        describe "group with matching metadata key", :foo do
+          it "runs the hook" do
+            expect(invoked_hooks).to eq([:before_example_foo_bar])
+          end
+        end
+      end
+      """
+    When I run `rspec filter_example_hooks_with_symbol_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Filtering hooks using a hash
+    Given a file named "filter_example_hooks_with_hash_spec.rb" with:
+      """ruby
+      RSpec.configure do |config|
+        config.before(:example, :foo => { :bar => :baz, :slow => true }) do
+          invoked_hooks << :before_example_foo_bar
+        end
+      end
+
+      RSpec.describe "a filtered before :example hook" do
+        let(:invoked_hooks) { [] }
+
+        describe "group without matching metadata" do
+          it "does not run the hook" do
+            expect(invoked_hooks).to be_empty
+          end
+
+          it "does not run the hook for an example if only part of the filter matches", :foo => { :bar => :baz } do
+            expect(invoked_hooks).to be_empty
+          end
+
+          it "runs the hook for an example if the metadata contains all key value pairs from the filter", :foo => { :bar => :baz, :slow => true, :extra => :pair } do
+            expect(invoked_hooks).to eq([:before_example_foo_bar])
+          end
+        end
+
+        describe "group with matching metadata", :foo => { :bar => :baz, :slow => true } do
+          it "runs the hook" do
+            expect(invoked_hooks).to eq([:before_example_foo_bar])
+          end
+        end
+      end
+      """
+    When I run `rspec filter_example_hooks_with_hash_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Filtering hooks using a Proc
+    Given a file named "filter_example_hooks_with_proc_spec.rb" with:
+      """ruby
+      RSpec.configure do |config|
+        config.before(:example, :foo => Proc.new { |value| value.is_a?(String) } ) do
+          invoked_hooks << :before_example_foo_bar
+        end
+      end
+
+      RSpec.describe "a filtered before :example hook" do
+        let(:invoked_hooks) { [] }
+
+        describe "group without matching metadata" do
+          it "does not run the hook" do
+            expect(invoked_hooks).to be_empty
+          end
+
+          it "does not run the hook if the proc returns false", :foo => :bar do
+            expect(invoked_hooks).to be_empty
+          end
+
+          it "runs the hook if the proc returns true", :foo => 'bar' do
+            expect(invoked_hooks).to eq([:before_example_foo_bar])
+          end
+        end
+
+        describe "group with matching metadata", :foo => 'bar' do
+          it "runs the hook" do
+            expect(invoked_hooks).to eq([:before_example_foo_bar])
+          end
+        end
+      end
+      """
+    When I run `rspec filter_example_hooks_with_proc_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Filtering hooks using a regular expression
+    Given a file named "filter_example_hooks_with_regexp_spec.rb" with:
+      """ruby
+      RSpec.configure do |config|
+        config.before(:example, :foo => /bar/ ) do
+          invoked_hooks << :before_example_foo_bar
+        end
+      end
+
+      RSpec.describe "a filtered before :example hook" do
+        let(:invoked_hooks) { [] }
+
+        describe "group without matching metadata" do
+          it "does not run the hook" do
+            expect(invoked_hooks).to be_empty
+          end
+
+          it "does not run the hook if the value does not match", :foo => 'baz' do
+            expect(invoked_hooks).to be_empty
+          end
+
+          it "runs the hook if the value matches", :foo => 'bar' do
+            expect(invoked_hooks).to eq([:before_example_foo_bar])
+          end
+        end
+
+        describe "group with matching metadata", :foo => 'bar' do
+          it "runs the hook" do
+            expect(invoked_hooks).to eq([:before_example_foo_bar])
+          end
+        end
+      end
+      """
+    When I run `rspec filter_example_hooks_with_regexp_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Filtering hooks using string comparison
+    Given a file named "filter_example_hooks_with_strcmp_spec.rb" with:
+      """ruby
+      RSpec.configure do |config|
+        config.before(:example, :foo => :bar ) do
+          invoked_hooks << :before_example_foo_bar
+        end
+      end
+
+      RSpec.describe "a filtered before :example hook" do
+        let(:invoked_hooks) { [] }
+
+        describe "group without matching metadata" do
+          it "does not run the hook" do
+            expect(invoked_hooks).to be_empty
+          end
+
+          it "does not run the hook if the coerced values do not match", :foo => 'baz' do
+            expect(invoked_hooks).to be_empty
+          end
+
+          it "runs the hook if the coerced values match", :foo => 'bar' do
+            expect(invoked_hooks).to eq([:before_example_foo_bar])
+          end
+        end
+
+        describe "group with matching metadata", :foo => 'bar' do
+          it "runs the hook" do
+            expect(invoked_hooks).to eq([:before_example_foo_bar])
+          end
+        end
+      end
+      """
+    When I run `rspec filter_example_hooks_with_strcmp_spec.rb`
+    Then the examples should all pass

data/rspec-core/upstream/features/hooks/when_first_matching_example_defined.feature

@@ -0,0 +1,70 @@
+Feature: `when_first_matching_example_defined` hook
+
+  In large projects that use RSpec, it's common to have some expensive setup logic
+  that is only needed when certain kinds of specs have been loaded. If that kind of
+  spec has not been loaded, you'd prefer to avoid the cost of doing the setup.
+
+  The `when_first_matching_example_defined` hook makes it easy to conditionally
+  perform some logic when the first example is defined with matching metadata,
+  allowing you to ensure the necessary setup is performed only when needed.
+
+  Background:
+    Given a file named "spec/spec_helper.rb" with:
+      """ruby
+      RSpec.configure do |config|
+        config.when_first_matching_example_defined(:db) do
+          require "support/db"
+        end
+      end
+      """
+    And a file named "spec/support/db.rb" with:
+      """ruby
+      RSpec.configure do |config|
+        config.before(:suite) do
+          puts "Bootstrapped the DB."
+        end
+
+        config.around(:example, :db) do |example|
+          puts "Starting a DB transaction."
+          example.run
+          puts "Rolling back a DB transaction."
+        end
+      end
+      """
+    And a file named ".rspec" with:
+      """
+      --require spec_helper
+      """
+    And a file named "spec/unit_spec.rb" with:
+      """
+      RSpec.describe "A unit spec" do
+        it "does not require a database" do
+          puts "in unit example"
+        end
+      end
+      """
+    And a file named "spec/integration_spec.rb" with:
+      """
+      RSpec.describe "An integration spec", :db do
+        it "requires a database" do
+          puts "in integration example"
+        end
+      end
+      """
+
+  Scenario: Running the entire suite loads the DB setup
+    When I run `rspec`
+    Then it should pass with:
+      """
+      Bootstrapped the DB.
+      Starting a DB transaction.
+      in integration example
+      Rolling back a DB transaction.
+      .in unit example
+      .
+      """
+
+  Scenario: Running just the unit spec does not load the DB setup
+    When I run `rspec spec/unit_spec.rb`
+    Then the examples should all pass
+    And the output should not contain "DB"