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

data/rspec-mocks/upstream/features/mutating_constants/README.md

@@ -0,0 +1,78 @@
+### Stubbing
+
+Support is provided for stubbing constants. Like with method stubs, the stubbed constants
+will be restored to their original state when an example completes.
+
+``` ruby
+stub_const("Foo", fake_foo)
+Foo # => fake_foo
+```
+
+Stubbed constant names must be fully qualified; the current module nesting is not
+considered.
+
+``` ruby
+module MyGem
+  class SomeClass; end
+end
+
+module MyGem
+  describe "Something" do
+    let(:fake_class) { Class.new }
+
+    it "accidentally stubs the wrong constant" do
+      # this stubs ::SomeClass (in the top-level namespace),
+      # not MyGem::SomeClass like you probably mean.
+      stub_const("SomeClass", fake_class)
+    end
+
+    it "stubs the right constant" do
+      stub_const("MyGem::SomeClass", fake_class)
+    end
+  end
+end
+```
+
+When you stub a constant that is a module or a class, nested constants on the original
+module or class are not transferred by default, but you can use the
+`:transfer_nested_constants` option to tell rspec-mocks to transfer them:
+
+``` ruby
+class CardDeck
+  SUITS = [:Spades, :Diamonds, :Clubs, :Hearts]
+  NUM_CARDS = 52
+end
+
+fake_class = Class.new
+stub_const("CardDeck", fake_class)
+CardDeck # => fake_class
+CardDeck::SUITS # => raises uninitialized constant error
+CardDeck::NUM_CARDS # => raises uninitialized constant error
+
+stub_const("CardDeck", fake_class, :transfer_nested_constants => true)
+CardDeck::SUITS # => [:Spades, :Diamonds, :Clubs, :Hearts]
+CardDeck::NUM_CARDS # => 52
+
+stub_const("CardDeck", fake_class, :transfer_nested_constants => [:SUITS])
+CardDeck::SUITS # => [:Spades, :Diamonds, :Clubs, :Hearts]
+CardDeck::NUM_CARDS # => raises uninitialized constant error
+```
+
+### Hiding
+
+Support is also provided for hiding constants. Hiding a constant temporarily removes it; it is
+restored to its original value after the test completes.
+
+```ruby
+FOO = 42
+hide_const("FOO")
+FOO => NameError: uninitialized constant FOO
+```
+
+Like stubbed constants, names must be fully qualified.
+
+Hiding constants that are already undefined has no effect.
+
+```ruby
+hide_const("NO_OP")
+```

data/rspec-mocks/upstream/features/mutating_constants/hide_defined_constant.feature

@@ -0,0 +1,64 @@
+Feature: Hide Defined Constant
+
+  Use `hide_const` to remove a constant for the duration of a test.
+
+  Scenario: Hide top-level constant
+    Given a file named "hide_const_spec.rb" with:
+      """ruby
+      FOO = 7
+
+      RSpec.describe "hiding FOO" do
+        it "can hide FOO" do
+          hide_const("FOO")
+          expect { FOO }.to raise_error(NameError)
+        end
+
+        it "restores the hidden constant when the example completes" do
+          expect(FOO).to eq(7)
+        end
+      end
+      """
+    When I run `rspec hide_const_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Hide nested constant
+    Given a file named "hide_const_spec.rb" with:
+      """ruby
+      module MyGem
+        class SomeClass
+          FOO = 7
+        end
+      end
+
+      module MyGem
+        RSpec.describe SomeClass do
+          it "hides the nested constant when it is fully qualified" do
+            hide_const("MyGem::SomeClass::FOO")
+            expect { SomeClass::FOO }.to raise_error(NameError)
+          end
+
+          it "restores the hidden constant when the example completes" do
+            expect(MyGem::SomeClass::FOO).to eq(7)
+          end
+        end
+      end
+      """
+    When I run `rspec hide_const_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Hiding undefined constant
+    Given a file named "hide_const_spec.rb" with:
+      """ruby
+      RSpec.describe "hiding UNDEFINED_CONSTANT" do
+        it "has no effect" do
+          hide_const("UNDEFINED_CONSTANT")
+          expect { UNDEFINED_CONSTANT }.to raise_error(NameError)
+        end
+
+        it "is still undefined after the example completes" do
+          expect { UNDEFINED_CONSTANT }.to raise_error(NameError)
+        end
+      end
+      """
+    When I run `rspec hide_const_spec.rb`
+    Then the examples should all pass

data/rspec-mocks/upstream/features/mutating_constants/hide_undefined_constant.feature

@@ -0,0 +1,22 @@
+Feature: Hide Undefined Constant
+
+  Hiding a constant that is already undefined is a no-op. This can be useful when a spec file
+  may run in either an isolated environment (e.g. when running one spec file) or in a full
+  environment with all parts of your code base loaded (e.g. when running your entire suite).
+
+  Scenario: Hiding undefined constant
+    Given a file named "hide_const_spec.rb" with:
+      """ruby
+      RSpec.describe "hiding UNDEFINED_CONSTANT" do
+        it "has no effect" do
+          hide_const("UNDEFINED_CONSTANT")
+          expect { UNDEFINED_CONSTANT }.to raise_error(NameError)
+        end
+
+        it "is still undefined after the example completes" do
+          expect { UNDEFINED_CONSTANT }.to raise_error(NameError)
+        end
+      end
+      """
+    When I run `rspec hide_const_spec.rb`
+    Then the examples should all pass

data/rspec-mocks/upstream/features/mutating_constants/stub_defined_constant.feature

@@ -0,0 +1,77 @@
+Feature: Stub Defined Constant
+
+  Use `stub_const` to stub constants. When the constant is already defined, the stubbed value
+  will replace the original value for the duration of the example.
+
+  Scenario: Stub top-level constant
+    Given a file named "stub_const_spec.rb" with:
+      """ruby
+      FOO = 7
+
+      RSpec.describe "stubbing FOO" do
+        it "can stub FOO with a different value" do
+          stub_const("FOO", 5)
+          expect(FOO).to eq(5)
+        end
+
+        it "restores the stubbed constant when the example completes" do
+          expect(FOO).to eq(7)
+        end
+      end
+      """
+    When I run `rspec stub_const_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Stub nested constant
+    Given a file named "stub_const_spec.rb" with:
+      """ruby
+      module MyGem
+        class SomeClass
+          FOO = 7
+        end
+      end
+
+      module MyGem
+        RSpec.describe SomeClass do
+          it "stubs the nested constant when it is fully qualified" do
+            stub_const("MyGem::SomeClass::FOO", 5)
+            expect(SomeClass::FOO).to eq(5)
+          end
+        end
+      end
+      """
+    When I run `rspec stub_const_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Transfer nested constants
+    Given a file named "stub_const_spec.rb" with:
+      """ruby
+      module MyGem
+        class SomeClass
+          FOO = 7
+        end
+      end
+
+      module MyGem
+        RSpec.describe SomeClass do
+          let(:fake_class) { Class.new }
+
+          it "does not transfer nested constants by default" do
+            stub_const("MyGem::SomeClass", fake_class)
+            expect { SomeClass::FOO }.to raise_error(NameError)
+          end
+
+          it "transfers nested constants when using :transfer_nested_constants => true" do
+            stub_const("MyGem::SomeClass", fake_class, :transfer_nested_constants => true)
+            expect(SomeClass::FOO).to eq(7)
+          end
+
+          it "can specify a list of nested constants to transfer" do
+            stub_const("MyGem::SomeClass", fake_class, :transfer_nested_constants => [:FOO])
+            expect(SomeClass::FOO).to eq(7)
+          end
+        end
+      end
+      """
+    When I run `rspec stub_const_spec.rb`
+    Then the examples should all pass

data/rspec-mocks/upstream/features/mutating_constants/stub_undefined_constant.feature

@@ -0,0 +1,50 @@
+Feature: Stub Undefined Constant
+
+  Use `stub_const` to stub constants. When the constant is not already defined, all the
+  necessary intermediary modules will be dynamically created. When the example completes,
+  the intermediary module constants will be removed to return the constant state to how it
+  started.
+
+  Scenario: Stub top-level constant
+    Given a file named "stub_const_spec.rb" with:
+      """ruby
+      RSpec.describe "stubbing FOO" do
+        it "can stub undefined constant FOO" do
+          stub_const("FOO", 5)
+          expect(FOO).to eq(5)
+        end
+
+        it "undefines the constant when the example completes" do
+          expect { FOO }.to raise_error(NameError)
+        end
+      end
+      """
+    When I run `rspec stub_const_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Stub nested constant
+    Given a file named "stub_const_spec.rb" with:
+      """ruby
+      module MyGem
+        class SomeClass
+        end
+      end
+
+      module MyGem
+        RSpec.describe SomeClass do
+          it "can stub an arbitrarily deep constant that is undefined" do
+            expect(defined?(SomeClass::A)).to be_falsey
+            stub_const("MyGem::SomeClass::A::B::C", 3)
+            expect(SomeClass::A::B::C).to eq(3)
+            expect(SomeClass::A).to be_a(Module)
+          end
+
+          it 'undefines the intermediary constants that were dynamically created' do
+            expect(defined?(SomeClass)).to be_truthy
+            expect(defined?(SomeClass::A)).to be_falsey
+          end
+        end
+      end
+      """
+    When I run `rspec stub_const_spec.rb`
+    Then the examples should all pass

data/rspec-mocks/upstream/features/old_syntax/README.md

@@ -0,0 +1,35 @@
+Historically, rspec-mocks has used a monkey-patched syntax to allow you to mock or stub any object:
+
+```ruby
+obj.stub(:foo).and_return(15)
+obj.should_receive(:bar)
+```
+
+Unfortunately, this is prone to weird, confusing failures when applied to [delegate/proxy
+objects](http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax#delegation_issues). For a method like `stub` to work properly, it must be defined on every object in the
+system, but RSpec does not own every object in the system and cannot ensure that it always
+works consistently.
+
+For this reason, in RSpec 2.14, we introduced a new syntax that avoids monkey patching
+altogether. It's the syntax shown in all examples of this documentation outside of this
+directory. As of RSpec 3, we consider this to be the main, recommended syntax of rspec-
+mocks. The old monkey-patched syntax continues to work, but you will get a deprecation
+warning if you use it without explicitly opting-in to it:
+
+```ruby
+# If you're using rspec-core:
+RSpec.configure do |config|
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :should
+  end
+end
+
+# Or, if you're using rspec-mocks in another context:
+RSpec::Mocks.configuration.syntax = :should
+```
+
+We have no plans to ever kill the old syntax, but we may extract it into an external gem in
+RSpec 4.
+
+If you have an old project that uses the old syntax and you want to update it to the current
+syntax, checkout [transpec](http://yujinakayama.me/transpec/).

data/rspec-mocks/upstream/features/old_syntax/any_instance.feature

@@ -0,0 +1,105 @@
+@allow-old-syntax
+Feature: `any_instance`
+
+  `any_instance` is the old way to stub or mock any instance of a class but carries the baggage of a global monkey patch on all classes.
+  Note that we [generally recommend against](../working-with-legacy-code/any-instance) using this feature.
+
+  Background:
+    Given a file named "spec/spec_helper.rb" with:
+      """ruby
+      RSpec.configure do |config|
+        config.mock_with :rspec do |mocks|
+          mocks.syntax = :should
+        end
+      end
+      """
+    And a file named ".rspec" with:
+      """
+      --require spec_helper
+      """
+
+  Scenario: Stub a method on any instance of a class
+    Given a file named "spec/example_spec.rb" with:
+      """ruby
+      RSpec.describe "Stubbing a method with any_instance" do
+        it "returns the specified value on any instance of the class" do
+          Object.any_instance.stub(:foo).and_return(:return_value)
+
+          o = Object.new
+          expect(o.foo).to eq(:return_value)
+        end
+      end
+      """
+    When I run `rspec spec/example_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Stub multiple methods on any instance of a class
+    Given a file named "spec/example_spec.rb" with:
+      """ruby
+      RSpec.describe "Stubbing multiple methods with any_instance" do
+        it "returns the specified values for the givne messages" do
+          Object.any_instance.stub(:foo => 'foo', :bar => 'bar')
+
+          o = Object.new
+          expect(o.foo).to eq('foo')
+          expect(o.bar).to eq('bar')
+        end
+      end
+      """
+    When I run `rspec spec/example_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Stubbing any instance of a class with specific arguments
+    Given a file named "spec/example_spec.rb" with:
+      """ruby
+      RSpec.describe "Stubbing any instance with arguments" do
+        it "returns the stubbed value when arguments match" do
+          Object.any_instance.stub(:foo).with(:param_one, :param_two).and_return(:result_one)
+          Object.any_instance.stub(:foo).with(:param_three, :param_four).and_return(:result_two)
+
+          o = Object.new
+          expect(o.foo(:param_one, :param_two)).to eq(:result_one)
+          expect(o.foo(:param_three, :param_four)).to eq(:result_two)
+        end
+      end
+      """
+    When I run `rspec spec/example_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Block implementation is passed the receiver as first arg
+    Given a file named "spec/example_spec.rb" with:
+      """ruby
+      RSpec.describe "Stubbing any instance of a class" do
+        it 'yields the receiver to the block implementation' do
+          Array.any_instance.stub(:shuffle) do |array|
+            array.unshift(array.pop)
+          end
+
+          expect([1, 2, 3].shuffle).to eq([3, 1, 2])
+        end
+      end
+      """
+    When I run `rspec spec/example_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Expect a message on any instance of a class
+    Given a file named "spec/example_spec.rb" with:
+      """ruby
+      RSpec.describe "Expecting a message on any instance of a class" do
+        before do
+          Object.any_instance.should_receive(:foo)
+        end
+
+        it "passes when an instance receives the message" do
+          Object.new.foo
+        end
+
+        it "fails when no instance receives the message" do
+          Object.new.to_s
+        end
+      end
+      """
+    When I run `rspec spec/example_spec.rb`
+    Then it should fail with the following output:
+      | 2 examples, 1 failure |
+      | Exactly one instance should have received the following message(s) but didn't: foo |

data/rspec-mocks/upstream/features/old_syntax/should_receive.feature

@@ -0,0 +1,90 @@
+@allow-old-syntax
+Feature: `should_receive`
+
+  `should_receive` is the old way to [expect messages](../basics/expecting-messages) but carries the
+  baggage of a global monkey patch on all objects. It supports the
+  same fluent interface for [setting constraints](../setting-constraints) and [configuring responses](../configuring-responses).
+
+  Similarly, you can use `should_not_receive` to set a negative message expectation.
+
+  Background:
+    Given a file named "spec/spec_helper.rb" with:
+      """ruby
+      RSpec.configure do |config|
+        config.mock_with :rspec do |mocks|
+          mocks.syntax = :should
+        end
+      end
+      """
+    And a file named ".rspec" with:
+      """
+      --require spec_helper
+      """
+
+  Scenario: Failing positive message expectation
+    Given a file named "spec/unfulfilled_message_expectation_spec.rb" with:
+      """ruby
+      RSpec.describe "An unfulfilled message expectation" do
+        it "triggers a failure" do
+          dbl = double("Some Collaborator")
+          dbl.should_receive(:foo)
+        end
+      end
+      """
+     When I run `rspec spec/unfulfilled_message_expectation_spec.rb`
+     Then it should fail with:
+      """
+        1) An unfulfilled message expectation triggers a failure
+           Failure/Error: dbl.should_receive(:foo)
+             (Double "Some Collaborator").foo(any args)
+                 expected: 1 time with any arguments
+                 received: 0 times with any arguments
+      """
+
+  Scenario: Passing positive message expectation
+    Given a file named "spec/fulfilled_message_expectation_spec.rb" with:
+      """ruby
+      RSpec.describe "A fulfilled message expectation" do
+        it "passes" do
+          dbl = double("Some Collaborator")
+          dbl.should_receive(:foo)
+          dbl.foo
+        end
+      end
+      """
+     When I run `rspec spec/fulfilled_message_expectation_spec.rb`
+     Then the examples should all pass
+
+  Scenario: Failing negative message expectation
+    Given a file named "spec/negative_message_expectation_spec.rb" with:
+      """ruby
+      RSpec.describe "A negative message expectation" do
+        it "fails when the message is received" do
+          dbl = double("Some Collaborator").as_null_object
+          dbl.should_not_receive(:foo)
+          dbl.foo
+        end
+      end
+      """
+     When I run `rspec spec/negative_message_expectation_spec.rb`
+     Then it should fail with:
+      """
+        1) A negative message expectation fails when the message is received
+           Failure/Error: dbl.foo
+             (Double "Some Collaborator").foo(no args)
+                 expected: 0 times with any arguments
+                 received: 1 time
+      """
+
+  Scenario: Passing negative message expectation
+    Given a file named "spec/negative_message_expectation_spec.rb" with:
+      """ruby
+      RSpec.describe "A negative message expectation" do
+        it "passes if the message is never received" do
+          dbl = double("Some Collaborator").as_null_object
+          dbl.should_not_receive(:foo)
+        end
+      end
+      """
+     When I run `rspec spec/negative_message_expectation_spec.rb`
+     Then the examples should all pass