rspec-core 2.99.2 → 3.0.0.beta1

data/features/filtering/exclusion_filters.feature

@@ -1,10 +1,8 @@
 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.
+  then tagging examples, or entire groups, with that filter.  You can also
+  specify metadata using only symbols.
 
   Scenario: exclude an example
     Given a file named "spec/sample_spec.rb" with:
@@ -120,7 +118,6 @@ Feature: exclusion filters
     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
 

data/features/filtering/inclusion_filters.feature

@@ -2,10 +2,7 @@ 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`.
+  a particular problem.  You can also specify metadata using only symbols.
 
   Background:
     Given a file named "spec/spec_helper.rb" with:
@@ -88,7 +85,6 @@ Feature: inclusion filters
     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
 

data/features/formatters/json_formatter.feature

@@ -5,11 +5,11 @@ Feature: JSON formatter
     """ruby
     describe "Various" do
       it "fails" do
-        "fail".should eq("succeed")
+        expect("fail").to eq("succeed")
       end
 
       it "succeeds" do
-        "succeed".should eq("succeed")
+        expect("succeed").to eq("succeed")
       end
 
       it "pends"

data/features/formatters/text_formatter.feature

@@ -9,7 +9,7 @@ Feature: text formatter
       """ruby
       describe String do
         it "has a failing example" do
-          "foo".reverse.should eq("ofo")
+          expect("foo".reverse).to eq("ofo")
         end
       end
       """
@@ -17,7 +17,7 @@ Feature: text formatter
       """ruby
       describe Integer do
         it "has a failing example" do
-          (7 + 5).should eq(11)
+          expect(7 + 5).to eq(11)
         end
       end
       """
@@ -25,7 +25,7 @@ Feature: text formatter
     Then the backtrace-normalized output should contain:
       """
         1) Integer has a failing example
-           Failure/Error: (7 + 5).should eq(11)
+           Failure/Error: expect(7 + 5).to eq(11)
              
              expected: 11
                   got: 12
@@ -36,7 +36,7 @@ Feature: text formatter
     And the backtrace-normalized output should contain:
       """
         2) String has a failing example
-           Failure/Error: "foo".reverse.should eq("ofo")
+           Failure/Error: expect("foo".reverse).to eq("ofo")
              
              expected: "ofo"
                   got: "oof"

data/features/helper_methods/arbitrary_methods.feature

@@ -14,7 +14,7 @@ Feature: arbitrary helper methods
         end
 
         it "has access to methods defined in its group" do
-          help.should be(:available)
+          expect(help).to be(:available)
         end
       end
       """
@@ -31,7 +31,7 @@ Feature: arbitrary helper methods
 
         describe "in a nested group" do
           it "has access to methods defined in its parent group" do
-            help.should be(:available)
+            expect(help).to be(:available)
           end
         end
       end

data/features/helper_methods/let.feature

@@ -15,12 +15,12 @@ Feature: let and let!
         let(:count) { $count += 1 }
 
         it "memoizes the value" do
-          count.should eq(1)
-          count.should eq(1)
+          expect(count).to eq(1)
+          expect(count).to eq(1)
         end
 
         it "is not cached across examples" do
-          count.should eq(2)
+          expect(count).to eq(2)
         end
       end
       """
@@ -41,8 +41,8 @@ Feature: let and let!
 
         it "calls the helper method in a before hook" do
           invocation_order << :example
-          invocation_order.should == [:let!, :example]
-          count.should eq(1)
+          expect(invocation_order).to eq([:let!, :example])
+          expect(count).to eq(1)
         end
       end
       """

data/features/helper_methods/modules.feature

@@ -8,10 +8,8 @@ Feature: Define helper methods in a module
 
   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.
+  that match the given metadata will include or extend the module. You
+  can also specify metadata using only symbols.
 
   Background:
     Given a file named "helpers.rb" with:
@@ -34,7 +32,7 @@ Feature: Define helper methods in a module
 
       describe "an example group" do
         it "has access to the helper methods defined in the module" do
-          help.should be(:available)
+          expect(help).to be(:available)
         end
       end
       """
@@ -73,7 +71,7 @@ Feature: Define helper methods in a module
 
       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)
+          expect(help).to be(:available)
         end
       end
 
@@ -122,7 +120,6 @@ Feature: Define helper methods in a module
       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
@@ -131,7 +128,7 @@ Feature: Define helper methods in a module
         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)
+          expect(help).to be(:available)
         end
       end
 

data/features/hooks/around_hooks.feature

@@ -192,7 +192,7 @@ Feature: around hooks
         end
 
         it "runs the example in the correct context" do
-          included_in_configure_block.should be_truthy
+          expect(included_in_configure_block).to be_truthy
         end
       end
       """
@@ -259,7 +259,7 @@ Feature: around hooks
 
         it "they should all be run" do
           puts "in the example"
-          1.should eq(1)
+          expect(1).to eq(1)
         end
       end
       """

data/features/hooks/before_and_after_hooks.feature

@@ -43,7 +43,7 @@ Feature: before and after hooks
 
         describe "initialized in before(:each)" do
           it "has 0 widgets" do
-            @thing.should have(0).widgets
+            expect(@thing.widgets.count).to eq(0)
           end
 
           it "can get accept new widgets" do
@@ -51,7 +51,7 @@ Feature: before and after hooks
           end
 
           it "does not share state across examples" do
-            @thing.should have(0).widgets
+            expect(@thing.widgets.count).to eq(0)
           end
         end
       end
@@ -77,7 +77,7 @@ Feature: before and after hooks
 
         describe "initialized in before(:all)" do
           it "has 0 widgets" do
-            @thing.should have(0).widgets
+            expect(@thing.widgets.count).to eq(0)
           end
 
           it "can get accept new widgets" do
@@ -85,7 +85,7 @@ Feature: before and after hooks
           end
 
           it "shares state across examples" do
-            @thing.should have(1).widgets
+            expect(@thing.widgets.count).to eq(1)
           end
         end
       end
@@ -191,12 +191,12 @@ Feature: before and after hooks
       describe "stuff in before blocks" do
         describe "with :all" do
           it "should be available in the example" do
-            @before_all.should eq("before all")
+            expect(@before_all).to eq("before all")
           end
         end
         describe "with :each" do
           it "should be available in the example" do
-            @before_each.should eq("before each")
+            expect(@before_each).to eq("before each")
           end
         end
       end
@@ -355,19 +355,19 @@ Feature: before and after hooks
 
         describe "nested" do
           it "access state set in before(:all)" do
-            @value.should eq(123)
+            expect(@value).to eq(123)
           end
 
           describe "nested more deeply" do
             it "access state set in before(:all)" do
-              @value.should eq(123)
+              expect(@value).to eq(123)
             end
           end
         end
 
         describe "nested in parallel" do
           it "access state set in before(:all)" do
-            @value.should eq(123)
+            expect(@value).to eq(123)
           end
         end
       end
@@ -384,7 +384,7 @@ Feature: before and after hooks
         end
 
         example "in outer group" do
-          @outer_state.should eq("set in outer before all")
+          expect(@outer_state).to eq("set in outer before all")
         end
 
         describe "nested group" do
@@ -393,17 +393,17 @@ Feature: before and after hooks
           end
 
           example "in nested group" do
-            @outer_state.should eq("set in outer before all")
-            @inner_state.should eq("set in inner before all")
+            expect(@outer_state).to eq("set in outer before all")
+            expect(@inner_state).to eq("set in inner before all")
           end
 
           after(:all) do
-            @inner_state.should eq("set in inner before all")
+            expect(@inner_state).to eq("set in inner before all")
           end
         end
 
         after(:all) do
-          @outer_state.should eq("set in outer before all")
+          expect(@outer_state).to eq("set in outer before all")
         end
       end
       """

data/features/hooks/filtering.feature

@@ -12,8 +12,7 @@ Feature: filters
       describe "something", :type => :model do
       end
 
-  You can specify metadata using only symbols if you set the
-  `treat_symbols_as_metadata_keys_with_true_values` config option to `true`.
+  You can also specify metadata using only symbols.
 
   Scenario: filter `before(:each)` hooks using arbitrary metadata
     Given a file named "filter_before_each_hooks_spec.rb" with:
@@ -29,17 +28,17 @@ Feature: filters
 
         describe "group without matching metadata" do
           it "does not run the hook" do
-            invoked_hooks.should be_empty
+            expect(invoked_hooks).to be_empty
           end
 
           it "runs the hook for an example with matching metadata", :foo => :bar do
-            invoked_hooks.should == [:before_each_foo_bar]
+            expect(invoked_hooks).to eq([:before_each_foo_bar])
           end
         end
 
         describe "group with matching metadata", :foo => :bar do
           it "runs the hook" do
-            invoked_hooks.should == [:before_each_foo_bar]
+            expect(invoked_hooks).to eq([:before_each_foo_bar])
           end
         end
       end
@@ -84,7 +83,7 @@ Feature: filters
         config.around(:each, :foo => :bar) do |example|
           order << :before_around_each_foo_bar
           example.run
-          order.should == [:before_around_each_foo_bar, :example]
+          expect(order).to eq([:before_around_each_foo_bar, :example])
         end
       end
 
@@ -93,18 +92,18 @@ Feature: filters
 
         describe "a group without matching metadata" do
           it "does not run the hook" do
-            order.should be_empty
+            expect(order).to be_empty
           end
 
           it "runs the hook for an example with matching metadata", :foo => :bar do
-            order.should == [:before_around_each_foo_bar]
+            expect(order).to eq([:before_around_each_foo_bar])
             order << :example
           end
         end
 
         describe "a group with matching metadata", :foo => :bar do
           it "runs the hook for an example with matching metadata", :foo => :bar do
-            order.should == [:before_around_each_foo_bar]
+            expect(order).to eq([:before_around_each_foo_bar])
             order << :example
           end
         end
@@ -123,24 +122,24 @@ Feature: filters
       describe "a filtered before(:all) hook" do
         describe "a group without matching metadata" do
           it "does not run the hook" do
-            @hook.should be_nil
+            expect(@hook).to be_nil
           end
 
           describe "a nested subgroup with matching metadata", :foo => :bar do
             it "runs the hook" do
-              @hook.should == :before_all_foo_bar
+              expect(@hook).to eq(:before_all_foo_bar)
             end
           end
         end
 
         describe "a group with matching metadata", :foo => :bar do
           it "runs the hook" do
-            @hook.should == :before_all_foo_bar
+            expect(@hook).to eq(:before_all_foo_bar)
           end
 
           describe "a nested subgroup" do
             it "runs the hook" do
-              @hook.should == :before_all_foo_bar
+              expect(@hook).to eq(:before_all_foo_bar)
             end
           end
         end
@@ -197,7 +196,6 @@ Feature: filters
     Given a file named "less_verbose_metadata_filter.rb" with:
       """ruby
       RSpec.configure do |c|
-        c.treat_symbols_as_metadata_keys_with_true_values = true
         c.before(:each, :before_each) { puts "before each" }
         c.after(:each,  :after_each) { puts "after each" }
         c.around(:each, :around_each) do |example|

data/features/metadata/described_class.feature

@@ -8,7 +8,7 @@ Feature: described class
       """ruby
       describe Fixnum do
         it "is available as described_class" do
-          described_class.should eq(Fixnum)
+          expect(described_class).to eq(Fixnum)
         end
       end
       """

data/features/metadata/user_defined.feature

@@ -8,16 +8,7 @@ Feature: User-defined metadata
   Metadata defined on an example group is available (and can be overridden)
   by any sub-group or from any example in that group or a sub-group.
 
-  In addition, there is a configuration option (which will be the default
-  behavior in RSpec 3) that allows you to specify metadata using just
-  symbols:
-
-  ```ruby
-  RSpec.configure do |c|
-    c.treat_symbols_as_metadata_keys_with_true_values = true
-  end
-  ```
-
+  In addition, you can specify metdata using just symbols.
   Each symbol passed as an argument to `describe`, `context` or `it` will
   be a key in the metadata hash, with a corresponding value of `true`.
 
@@ -26,20 +17,20 @@ Feature: User-defined metadata
       """ruby
       describe "a group with user-defined metadata", :foo => 17 do
         it 'has access to the metadata in the example' do |example|
-          example.metadata[:foo].should eq(17)
+          expect(example.metadata[:foo]).to eq(17)
         end
 
         it 'does not have access to metadata defined on sub-groups' do |example|
-          example.metadata.should_not include(:bar)
+          expect(example.metadata).not_to include(:bar)
         end
 
         describe 'a sub-group with user-defined metadata', :bar => 12 do
           it 'has access to the sub-group metadata' do |example|
-            example.metadata[:foo].should eq(17)
+            expect(example.metadata[:foo]).to eq(17)
           end
 
           it 'also has access to metadata defined on parent groups' do |example|
-            example.metadata[:bar].should eq(12)
+            expect(example.metadata[:bar]).to eq(12)
           end
         end
       end
@@ -52,14 +43,14 @@ Feature: User-defined metadata
       """ruby
       describe "a group with no user-defined metadata" do
         it 'has an example with metadata', :foo => 17 do |example|
-          example.metadata[:foo].should eq(17)
-          example.metadata.should_not include(:bar)
+          expect(example.metadata[:foo]).to eq(17)
+          expect(example.metadata).not_to include(:bar)
         end
 
         it 'has another example with metadata', :bar => 12, :bazz => 33 do |example|
-          example.metadata[:bar].should eq(12)
-          example.metadata[:bazz].should eq(33)
-          example.metadata.should_not include(:foo)
+          expect(example.metadata[:bar]).to eq(12)
+          expect(example.metadata[:bazz]).to eq(33)
+          expect(example.metadata).not_to include(:foo)
         end
       end
       """
@@ -71,12 +62,12 @@ Feature: User-defined metadata
       """ruby
       describe "a group with user-defined metadata", :foo => 'bar' do
         it 'can be overridden by an example', :foo => 'bazz' do |example|
-          example.metadata[:foo].should == 'bazz'
+          expect(example.metadata[:foo]).to eq('bazz')
         end
 
         describe "a sub-group with an override", :foo => 'goo' do
           it 'can be overridden by a sub-group' do |example|
-            example.metadata[:foo].should == 'goo'
+            expect(example.metadata[:foo]).to eq('goo')
           end
         end
       end
@@ -87,25 +78,21 @@ Feature: User-defined metadata
   Scenario: less verbose metadata
     Given a file named "less_verbose_metadata_spec.rb" with:
       """ruby
-      RSpec.configure do |c|
-        c.treat_symbols_as_metadata_keys_with_true_values = true
-      end
-
       describe "a group with simple metadata", :fast, :simple, :bug => 73 do
         it 'has `:fast => true` metadata' do |example|
-          example.metadata[:fast].should == true
+          expect(example.metadata[:fast]).to eq(true)
         end
 
         it 'has `:simple => true` metadata' do |example|
-          example.metadata[:simple].should == true
+          expect(example.metadata[:simple]).to eq(true)
         end
 
         it 'can still use a hash for metadata' do |example|
-          example.metadata[:bug].should eq(73)
+          expect(example.metadata[:bug]).to eq(73)
         end
 
         it 'can define simple metadata on an example', :special do |example|
-          example.metadata[:special].should == true
+          expect(example.metadata[:special]).to eq(true)
         end
       end
       """