opal-rspec 0.7.0.rc.1 → 0.7.0.rc.2

data/rspec-core/upstream/features/command_line/order.md

@@ -0,0 +1,23 @@
+Use the `--order` option to tell RSpec how to order the files, groups, and
+examples. The available ordering schemes are `defined` and `rand`.
+
+`defined` is the default, which executes groups and examples in the order they
+are defined as the spec files are loaded.
+
+Use `rand` to randomize the order of groups and examples within the groups.
+Nested groups are always run from top-level to bottom-level in order to avoid
+executing `before(:context)` and `after(:context)` hooks more than once, but the
+order of groups at each level is randomized.
+
+With `rand` you can also specify a seed.
+
+## Example usage
+
+The `defined` option is only necessary when you have `--order rand` stored in a
+config file (e.g. `.rspec`) and you want to override it from the command line.
+
+<pre><code class="bash">--order defined
+--order rand
+--order rand:123
+--seed 123 # same as --order rand:123
+</code></pre>

data/rspec-core/upstream/features/command_line/pattern_option.feature

@@ -0,0 +1,42 @@
+Feature: `--pattern` option
+
+  By default, RSpec loads files matching the pattern:
+
+      "spec/**/*_spec.rb"
+
+  Use the `--pattern` option to declare a different pattern.
+
+  Background:
+    Given a file named "spec/example_spec.rb" with:
+      """ruby
+      RSpec.describe "two specs" do
+        it "passes" do
+        end
+
+        it "passes too" do
+        end
+      end
+      """
+    And a file named "spec/example_test.rb" with:
+      """ruby
+      RSpec.describe "one spec" do
+        it "passes" do
+        end
+      end
+      """
+
+  Scenario: By default, RSpec runs files that match `"**/*_spec.rb"`
+   When I run `rspec`
+   Then the output should contain "2 examples, 0 failures"
+
+  Scenario: The `--pattern` flag makes RSpec run files matching the specified pattern and ignore the default pattern
+   When I run `rspec -P "**/*_test.rb"`
+   Then the output should contain "1 example, 0 failures"
+
+  Scenario: The `--pattern` flag can be used to pass in multiple patterns, separated by commas
+   When I run `rspec -P "**/*_test.rb,**/*_spec.rb"`
+   Then the output should contain "3 examples, 0 failures"
+
+  Scenario: The `--pattern` flag accepts shell style glob unions
+   When I run `rspec -P "**/*_{test,spec}.rb"`
+   Then the output should contain "3 examples, 0 failures"

data/rspec-core/upstream/features/command_line/rake_task.feature

@@ -0,0 +1,158 @@
+Feature: rake task
+
+  RSpec ships with a rake task with a number of useful options.
+
+  We recommend you wrap this in a `rescue` clause so that you can
+  use your `Rakefile` in an environment where RSpec is unavailable
+  (for example on a production server). e.g:
+
+  ```ruby
+  begin
+    require 'rspec/core/rake_task'
+    RSpec::Core::RakeTask.new(:spec)
+  rescue LoadError
+  end
+  ```
+
+  Scenario: Default options with passing spec (prints command and exit status is 0)
+    Given a file named "Rakefile" with:
+      """ruby
+
+      begin
+        require 'rspec/core/rake_task'
+
+        RSpec::Core::RakeTask.new(:spec)
+
+        task :default => :spec
+      rescue LoadError
+        # no rspec available
+      end
+      """
+    And a file named "spec/thing_spec.rb" with:
+      """ruby
+      RSpec.describe "something" do
+        it "does something" do
+          # pass
+        end
+      end
+      """
+    When I run `rake`
+    Then the output should match:
+      """
+      (ruby|rbx) -I\S+ [\/\S]+\/exe\/rspec
+      """
+    Then the exit status should be 0
+
+  Scenario: Default options with failing spec (exit status is 1)
+    Given a file named "Rakefile" with:
+      """ruby
+      begin
+        require 'rspec/core/rake_task'
+
+        RSpec::Core::RakeTask.new(:spec)
+
+        task :default => :spec
+      rescue LoadError
+        # no rspec available
+      end
+      """
+    And a file named "spec/thing_spec.rb" with:
+      """ruby
+      RSpec.describe "something" do
+        it "does something" do
+          fail
+        end
+      end
+      """
+    When I run `rake`
+    Then the exit status should be 1
+
+  Scenario: Setting `fail_on_error = false` with failing spec (exit status is 0)
+    Given a file named "Rakefile" with:
+      """ruby
+      begin
+        require 'rspec/core/rake_task'
+
+        RSpec::Core::RakeTask.new(:spec) do |t|
+          t.fail_on_error = false
+        end
+
+        task :default => :spec
+      rescue LoadError
+        # no rspec available
+      end
+      """
+    And a file named "spec/thing_spec.rb" with:
+      """ruby
+      RSpec.describe "something" do
+        it "does something" do
+          fail
+        end
+      end
+      """
+    When I run `rake`
+    Then the exit status should be 0
+
+  Scenario: Passing arguments to the `rspec` command using `rspec_opts`
+    Given a file named "Rakefile" with:
+      """ruby
+      begin
+        require 'rspec/core/rake_task'
+
+        RSpec::Core::RakeTask.new(:spec) do |t|
+          t.rspec_opts = "--tag fast"
+        end
+      rescue LoadError
+        # no rspec available
+      end
+      """
+    And a file named "spec/thing_spec.rb" with:
+      """ruby
+      RSpec.describe "something" do
+        it "has a tag", :fast => true do
+          # pass
+        end
+
+        it "does not have a tag" do
+          fail
+        end
+      end
+      """
+    When I run `rake spec`
+    Then the exit status should be 0
+    Then the output should match:
+      """
+      (ruby|rbx) -I\S+ [\/\S]+\/exe\/rspec --pattern spec[\/\\*{,}]+_spec.rb --tag fast
+      """
+
+  Scenario: Passing rake task arguments to the `rspec` command via `rspec_opts`
+    Given a file named "Rakefile" with:
+      """ruby
+      begin
+        require 'rspec/core/rake_task'
+
+        RSpec::Core::RakeTask.new(:spec, :tag) do |t, task_args|
+          t.rspec_opts = "--tag #{task_args[:tag]}"
+        end
+      rescue LoadError
+        # no rspec available
+      end
+      """
+    And a file named "spec/thing_spec.rb" with:
+      """ruby
+      RSpec.describe "something" do
+        it "has a tag", :fast => true do
+          # pass
+        end
+
+        it "does not have a tag" do
+          fail
+        end
+      end
+      """
+    When I run `rake spec[fast]`
+    Then the exit status should be 0
+    Then the output should match:
+      """
+      (ruby|rbx) -I\S+ [\/\S]+\/exe\/rspec --pattern spec[\/\\*{,}]+_spec.rb --tag fast
+      """

data/rspec-core/upstream/features/command_line/randomization.feature

@@ -0,0 +1,62 @@
+Feature: Randomization can be reproduced across test runs
+
+  In Ruby, randomness is seeded by calling `srand` and passing it the seed that
+  you want to use. By doing this, subsequent calls to `rand`, `shuffle`,
+  `sample`, etc. will all be randomized the same way given the same seed is
+  passed to `srand`.
+
+  RSpec takes care not to seed randomization directly when taking action that
+  involves randomness (such as random ordering of examples).
+
+  Since RSpec does not ever invoke `srand`, this means that you are free to
+  choose which, if any, mechanism is used to seed randomization.
+
+  There is an example below of how to use RSpec's seed for this purpose if you
+  wish to do so.
+
+  If you would like to manage seeding randomization without any help from RSpec,
+  please keep the following things in mind:
+
+    * The seed should never be hard-coded.
+
+      The first example below only does this to show that seeding randomization
+      with a seed other than the one used by RSpec will correctly seed
+      randomization.
+
+    * Report the seed that was chosen.
+
+      The randomization that was used for a given test run can not be reproduced
+      if no one knows what seed was used to begin with.
+
+    * Provide a mechanism to feed the seed into the tests.
+
+      Without this, the call to `srand` will have to be hard-coded any time it
+      is necessary to replicate a given test run's randomness.
+
+  Background:
+    Given a file named "spec/random_spec.rb" with:
+      """ruby
+      require 'spec_helper'
+
+      RSpec.describe 'randomized example' do
+        it 'prints random numbers' do
+          puts 5.times.map { rand(99) }.join("-")
+        end
+      end
+      """
+
+  Scenario: Specifying a seed using `srand` provides predictable randomization
+    Given a file named "spec/spec_helper.rb" with:
+      """ruby
+      srand 123
+      """
+    When I run `rspec`
+    Then the output should contain "66-92-98-17-83"
+
+  Scenario: Passing the RSpec seed to `srand` provides predictable randomization
+    Given a file named "spec/spec_helper.rb" with:
+      """ruby
+      srand RSpec.configuration.seed
+      """
+    When I run `rspec --seed 123`
+    Then the output should contain "66-92-98-17-83"

data/rspec-core/upstream/features/command_line/require_option.feature

@@ -0,0 +1,45 @@
+Feature: `--require` option
+
+  Use the `--require` (or `-r`) option to specify a file to require before
+  running specs.
+
+  Scenario: Using the `--require` option
+    Given a file named "logging_formatter.rb" with:
+      """ruby
+      require "rspec/core/formatters/base_text_formatter"
+      require 'delegate'
+
+      class LoggingFormatter < RSpec::Core::Formatters::BaseTextFormatter
+        RSpec::Core::Formatters.register self, :dump_summary
+
+        def initialize(output)
+          super LoggingIO.new(output)
+        end
+
+        class LoggingIO < SimpleDelegator
+          def initialize(output)
+            @file = File.new('rspec.log', 'w')
+            super
+          end
+
+          def puts(*args)
+            [@file, __getobj__].each { |out| out.puts(*args) }
+          end
+
+          def close
+            @file.close
+          end
+        end
+      end
+      """
+    And a file named "spec/example_spec.rb" with:
+      """ruby
+      RSpec.describe "an embarassing situation" do
+        it "happens to everyone" do
+        end
+      end
+      """
+    When I run `rspec --require ./logging_formatter.rb --format LoggingFormatter`
+    Then the output should contain "1 example, 0 failures"
+    And  the file "rspec.log" should contain "1 example, 0 failures"
+    And  the exit status should be 0

data/rspec-core/upstream/features/command_line/ruby.feature

@@ -0,0 +1,23 @@
+Feature: run with `ruby` command
+
+  You can use the `ruby` command to run specs. You just need to require
+  `rspec/autorun`.
+
+  Generally speaking, you're better off using the `rspec` command, which avoids
+  the complexity of `rspec/autorun` (e.g. no `at_exit` hook needed!), but some
+  tools only work with the `ruby` command.
+
+  Scenario: Require `rspec/autorun` from a spec file
+    Given a file named "example_spec.rb" with:
+      """ruby
+      require 'rspec/autorun'
+
+      RSpec.describe 1 do
+        it "is < 2" do
+          expect(1).to be < 2
+        end
+      end
+      """
+    When I run `ruby example_spec.rb`
+    Then the output should contain "1 example, 0 failures"
+

data/rspec-core/upstream/features/command_line/tag.feature

@@ -0,0 +1,102 @@
+Feature: `--tag` option
+
+  Use the `--tag` (or `-t`) option to filter the examples by tags.
+
+  The tag can be a simple `name` or a `name:value` pair. In the first case,
+  examples with `:name => true` will be filtered. In the second case, examples
+  with `:name => value` will be filtered, where `value` is always a string. In
+  both cases, `name` is converted to a symbol.
+
+  Filters are represented internally as a hash, which means that you can't
+  specify multiple filters for the same key. If you try to exclude `:name => 'foo'`
+  and `:name => 'bar'`, you will only end up excluding `:name => 'bar'`.
+
+  Tags can also be used to exclude examples by adding a `~` before the tag. For
+  example `~tag` will exclude all examples marked with `:tag => true` and
+  `~tag:value` will exclude all examples marked with `:tag => value`.
+
+  To be compatible with the Cucumber syntax, tags can optionally start with an
+  `@` symbol, which will be ignored.
+
+  Background:
+    Given a file named "tagged_spec.rb" with:
+      """ruby
+      RSpec.describe "group with tagged specs" do
+        it "example I'm working now", :focus => true do; end
+        it "special example with string", :type => 'special' do; end
+        it "special example with symbol", :type => :special do; end
+        it "slow example", :skip => true do; end
+        it "ordinary example", :speed => 'slow' do; end
+        it "untagged example" do; end
+      end
+      """
+
+  Scenario: Filter examples with non-existent tag
+    When I run `rspec . --tag mytag`
+    Then the process should succeed even though no examples were run
+
+  Scenario: Filter examples with a simple tag
+    When I run `rspec . --tag focus`
+    Then the output should contain "include {:focus=>true}"
+    And the examples should all pass
+
+  Scenario: Filter examples with a simple tag and @
+    When I run `rspec . --tag @focus`
+    Then the output should contain "include {:focus=>true}"
+    Then the examples should all pass
+
+  Scenario: Filter examples with a `name:value` tag
+    When I run `rspec . --tag type:special`
+    Then the output should contain:
+      """
+      include {:type=>"special"}
+      """
+    And the output should contain "2 examples"
+    And the examples should all pass
+
+  Scenario: Filter examples with a `name:value` tag and @
+    When I run `rspec . --tag @type:special`
+    Then the output should contain:
+      """
+      include {:type=>"special"}
+      """
+    And the examples should all pass
+
+  Scenario: Exclude examples with a simple tag
+    When I run `rspec . --tag ~skip`
+    Then the output should contain "exclude {:skip=>true}"
+    Then the examples should all pass
+
+  Scenario: Exclude examples with a simple tag and @
+    When I run `rspec . --tag ~@skip`
+    Then the output should contain "exclude {:skip=>true}"
+    Then the examples should all pass
+
+  Scenario: Exclude examples with a `name:value` tag
+    When I run `rspec . --tag ~speed:slow`
+    Then the output should contain:
+      """
+      exclude {:speed=>"slow"}
+      """
+    Then the examples should all pass
+
+  Scenario: Exclude examples with a `name:value` tag and @
+    When I run `rspec . --tag ~@speed:slow`
+    Then the output should contain:
+      """
+      exclude {:speed=>"slow"}
+      """
+    Then the examples should all pass
+
+  Scenario: Filter examples with a simple tag, exclude examples with another tag
+    When I run `rspec . --tag focus --tag ~skip`
+    Then the output should contain "include {:focus=>true}"
+    And the output should contain "exclude {:skip=>true}"
+    And the examples should all pass
+
+  Scenario: Exclude examples with multiple tags
+    When I run `rspec . --tag ~skip --tag ~speed:slow`
+    Then the output should contain one of the following:
+      | exclude {:skip=>true, :speed=>"slow"} |
+      | exclude {:speed=>"slow", :skip=>true} |
+    Then the examples should all pass