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

data/rspec-mocks/upstream/features/setting_constraints/receive_counts.feature

@@ -0,0 +1,189 @@
+Feature: Receive Counts
+
+  When [expecting a message](../basics/expecting-messages), you can specify how many times you expect the message to be
+  received:
+
+    * `expect(...).to receive(...).once`
+    * `expect(...).to receive(...).twice`
+    * `expect(...).to receive(...).exactly(n).times`
+    * `expect(...).to receive(...).at_least(:once)`
+    * `expect(...).to receive(...).at_least(:twice)`
+    * `expect(...).to receive(...).at_least(n).times`
+    * `expect(...).to receive(...).at_most(:once)`
+    * `expect(...).to receive(...).at_most(:twice)`
+    * `expect(...).to receive(...).at_most(n).times`
+
+  If you don't specify an expected receive count, it defaults to `once`.
+
+  Background:
+    Given a file named "lib/account.rb" with:
+      """ruby
+      class Account
+        def initialize(logger)
+          @logger = logger
+        end
+
+        def open
+          @logger.account_opened
+        end
+      end
+      """
+
+  Scenario: Passing examples
+    Given a file named "spec/account_spec.rb" with:
+      """ruby
+      require 'account'
+
+      RSpec.describe Account do
+        let(:logger)  { double("Logger") }
+        let(:account) { Account.new(logger) }
+
+        example "once" do
+          expect(logger).to receive(:account_opened).once
+          account.open
+        end
+
+        example "twice" do
+          expect(logger).to receive(:account_opened).twice
+          account.open
+          account.open
+        end
+
+        example "exactly(n).times" do
+          expect(logger).to receive(:account_opened).exactly(3).times
+          account.open
+          account.open
+          account.open
+        end
+
+        example "at_least(:once)" do
+          expect(logger).to receive(:account_opened).at_least(:once)
+          account.open
+          account.open
+        end
+
+        example "at_least(:twice)" do
+          expect(logger).to receive(:account_opened).at_least(:twice)
+          account.open
+          account.open
+          account.open
+        end
+
+        example "at_least(n).times" do
+          expect(logger).to receive(:account_opened).at_least(3).times
+          account.open
+          account.open
+          account.open
+          account.open
+        end
+
+        example "at_most(:once)" do
+          expect(logger).to receive(:account_opened).at_most(:once)
+        end
+
+        example "at_most(:twice)" do
+          expect(logger).to receive(:account_opened).at_most(:twice)
+          account.open
+        end
+
+        example "at_most(n).times" do
+          expect(logger).to receive(:account_opened).at_most(3).times
+          account.open
+          account.open
+        end
+      end
+      """
+    When I run `rspec spec/account_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Failing examples
+    Given a file named "spec/account_spec.rb" with:
+      """ruby
+      require 'account'
+
+      RSpec.describe Account do
+        let(:logger)  { double("Logger") }
+        let(:account) { Account.new(logger) }
+
+        example "once" do
+          expect(logger).to receive(:account_opened).once
+          account.open
+          account.open
+        end
+
+        example "twice" do
+          expect(logger).to receive(:account_opened).twice
+          account.open
+        end
+
+        example "exactly(n).times" do
+          expect(logger).to receive(:account_opened).exactly(3).times
+          account.open
+          account.open
+        end
+
+        example "at_least(:once)" do
+          expect(logger).to receive(:account_opened).at_least(:once)
+        end
+
+        example "at_least(:twice)" do
+          expect(logger).to receive(:account_opened).at_least(:twice)
+          account.open
+        end
+
+        example "at_least(n).times" do
+          expect(logger).to receive(:account_opened).at_least(3).times
+          account.open
+          account.open
+        end
+
+        example "at_most(:once)" do
+          expect(logger).to receive(:account_opened).at_most(:once)
+          account.open
+          account.open
+        end
+
+        example "at_most(:twice)" do
+          expect(logger).to receive(:account_opened).at_most(:twice)
+          account.open
+          account.open
+          account.open
+        end
+
+        example "at_most(n).times" do
+          expect(logger).to receive(:account_opened).at_most(3).times
+          account.open
+          account.open
+          account.open
+          account.open
+        end
+      end
+      """
+    When I run `rspec spec/account_spec.rb --order defined`
+    Then the examples should all fail, producing the following output:
+      | expected: 1 time with any arguments           |
+      | received: 2 times                             |
+      |                                               |
+      | expected: 2 times with any arguments          |
+      | received: 1 time with any arguments           |
+      |                                               |
+      | expected: 3 times with any arguments          |
+      | received: 2 times with any arguments          |
+      |                                               |
+      | expected: at least 1 time with any arguments  |
+      | received: 0 times with any arguments          |
+      |                                               |
+      | expected: at least 2 times with any arguments |
+      | received: 1 time with any arguments           |
+      |                                               |
+      | expected: at least 3 times with any arguments |
+      | received: 2 times with any arguments          |
+      |                                               |
+      | expected: at most 1 time with any arguments   |
+      | received: 2 times                             |
+      |                                               |
+      | expected: at most 2 times with any arguments  |
+      | received: 3 times                             |
+      |                                               |
+      | expected: at most 3 times with any arguments  |
+      | received: 4 times                             |

data/rspec-mocks/upstream/features/step_definitions/additional_cli_steps.rb

@@ -0,0 +1,21 @@
+Then /^the example(?:s)? should(?: all)? pass$/ do
+  step %q{the output should contain "0 failures"}
+  step %q{the exit status should be 0}
+end
+
+Then /^the examples should all fail, producing the following output:$/ do |table|
+  step %q{the exit status should be 1}
+  examples, failures = all_output.match(/(\d+) examples?, (\d+) failures?/).captures.map(&:to_i)
+
+  expect(examples).to be > 0
+  expect(examples).to eq(failures)
+
+  lines = table.raw.flatten.reject(&:empty?)
+  expect(all_output).to include(*lines)
+end
+
+Then /^it should fail with the following output:$/ do |table|
+  step %q{the exit status should be 1}
+  lines = table.raw.flatten.reject(&:empty?)
+  expect(all_output).to include(*lines)
+end

data/rspec-mocks/upstream/features/support/disallow_certain_apis.rb

@@ -0,0 +1,24 @@
+# This file is designed to prevent the use of certain APIs that
+# we don't want used from our cukes, since they function as documentation.
+
+if defined?(Cucumber)
+  require 'shellwords'
+  Before('~@allow-old-syntax') do
+    set_env('SPEC_OPTS', "-r#{Shellwords.escape(__FILE__)}")
+  end
+else
+  module DisallowOneLinerShould
+    def should(*)
+      raise "one-liner should is not allowed"
+    end
+
+    def should_not(*)
+      raise "one-liner should_not is not allowed"
+    end
+  end
+
+  RSpec.configure do |rspec|
+    rspec.disable_monkey_patching!
+    rspec.include DisallowOneLinerShould
+  end
+end

data/rspec-mocks/upstream/features/support/env.rb

@@ -0,0 +1,22 @@
+require 'aruba/cucumber'
+require 'rspec/expectations'
+
+Before do
+  if RUBY_PLATFORM =~ /java/ || defined?(Rubinius)
+    @aruba_timeout_seconds = 60
+  else
+    @aruba_timeout_seconds = 5
+  end
+end
+
+Aruba.configure do |config|
+  config.before_cmd do |cmd|
+    set_env('JRUBY_OPTS', "-X-C #{ENV['JRUBY_OPTS']}") # disable JIT since these processes are so short lived
+  end
+end if RUBY_PLATFORM == 'java'
+
+Aruba.configure do |config|
+  config.before_cmd do |cmd|
+    set_env('RBXOPT', "-Xint=true #{ENV['RBXOPT']}") # disable JIT since these processes are so short lived
+  end
+end if defined?(Rubinius)

data/rspec-mocks/upstream/features/support/rubinius.rb

@@ -0,0 +1,6 @@
+# Required until https://github.com/rubinius/rubinius/issues/2430 is resolved
+ENV['RBXOPT'] = "#{ENV["RBXOPT"]} -Xcompiler.no_rbc"
+
+Around "@unsupported-on-rbx" do |scenario, block|
+  block.call unless defined?(Rubinius)
+end

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

@@ -0,0 +1,13 @@
+Verifying doubles are a stricter alternative to [normal doubles](./basics/test-doubles) that provide guarantees about
+what is being verified. When using verifying doubles, RSpec will check that the methods
+being stubbed are actually present on the underlying object if it is available. Prefer using
+veryifing doubles over normal doubles.
+
+No checking will happen if the underlying object or class is not defined, but when run with
+it present (either as a full spec run or by explicitly preloading collaborators) a failure will be
+triggered if an invalid method is being stubbed or a method is called with an invalid
+number of arguments.
+
+This dual approach allows you to move very quickly and test components in isolation, while
+giving you confidence that your doubles are not a complete fiction. Testing in isolation is
+optional but recommend for classes that do not depend on third-party components.

data/rspec-mocks/upstream/features/verifying_doubles/class_doubles.feature

@@ -0,0 +1,70 @@
+Feature: Using a class double
+
+  `class_double` is provided as a complement to [`instance_double`](./using-an-instance-double) with the difference that it
+  verifies _class_ methods on the given class rather than instance methods.
+
+  In addition, it also provides a convenience method `as_stubbed_const` to replace concrete
+  classes with the defined double. See [mutating constants](../mutating-constants) for more details.
+
+  Note: `class_double` can be used for modules as well. We chose to stick with the
+  `class_double` terminology because the methods a `class_double` verifies against are
+  commonly called "class methods", not "module methods", even when working with a module.
+
+  Background:
+    Given a file named "lib/user.rb" with:
+      """ruby
+      class User
+        def suspend!
+          ConsoleNotifier.notify("suspended as")
+        end
+      end
+      """
+
+    Given a file named "lib/console_notifier.rb" with:
+      """ruby
+      class ConsoleNotifier
+        MAX_WIDTH = 80
+
+        def self.notify(message)
+          puts message
+        end
+      end
+      """
+
+    Given a file named "spec/user_spec.rb" with:
+      """ruby
+      require 'user'
+      require 'console_notifier'
+
+      RSpec.describe User, '#suspend!' do
+        it 'notifies the console' do
+          notifier = class_double("ConsoleNotifier").
+            as_stubbed_const(:transfer_nested_constants => true)
+
+          expect(notifier).to receive(:notify).with("suspended as")
+          expect(ConsoleNotifier::MAX_WIDTH).to eq(80)
+
+          user = User.new
+          user.suspend!
+        end
+      end
+      """
+
+  Scenario: replacing existing constants
+    When I run `rspec spec/user_spec.rb`
+    Then the examples should all pass
+
+  Scenario: renaming `ConsoleNotifier.notify` to `send_notification`
+    Given a file named "lib/console_notifier.rb" with:
+      """ruby
+      class ConsoleNotifier
+        MAX_WIDTH = 80
+
+        def self.send_notification(message)
+          puts message
+        end
+      end
+      """
+    When I run `rspec spec/user_spec.rb`
+    Then the output should contain "1 example, 1 failure"
+    And the output should contain "ConsoleNotifier does not implement:"

data/rspec-mocks/upstream/features/verifying_doubles/dynamic_classes.feature

@@ -0,0 +1,73 @@
+Feature: Dynamic classes
+
+  Verifying instance doubles do not support methods which the class reports to not exist
+  since an actual instance of the class would be required to verify against. This is commonly
+  the case when `method_missing` is used. For example, `ActiveRecord` does this to define
+  methods from database columns.
+
+  There are a few ways to work around this. If the object has already been loaded you may
+  consider using an [`object_double`](./using-an-object-double), but that cannot work if you
+  are testing in isolation. Alternatively you could implement the methods directly (calling
+  `super` to return the `method_missing` definition).
+
+  These types of methods are supported at class level (with `class_double`) however, since
+  `respond_to?` can be queried directly on the class.
+
+  Background:
+    Given a file named "lib/fake_active_record.rb" with:
+      """ruby
+      class FakeActiveRecord
+        COLUMNS = %w[name email]
+
+        def respond_to_missing?(method_name)
+          COLUMNS.include?(method_name.to_s) || super
+        end
+
+        def method_missing(method_name, *args)
+          if respond_to?(method_name)
+            instance_variable_get("@#{method_name}")
+          else
+            super
+          end
+        end
+      end
+      """
+
+    Given a file named "spec/user_spec.rb" with:
+      """ruby
+      require 'user'
+
+      RSpec.describe User do
+        it 'can be doubled' do
+          instance_double("User", :name => "Don")
+        end
+      end
+      """
+
+  Scenario: fails with method missing
+
+    Given a file named "lib/user.rb" with:
+      """ruby
+      require 'fake_active_record'
+
+      class User < FakeActiveRecord
+      end
+      """
+
+    When I run `rspec spec/user_spec.rb`
+    Then the output should contain "1 example, 1 failure"
+
+  Scenario: workaround with explict definitions
+
+    Given a file named "lib/user.rb" with:
+      """ruby
+      require 'fake_active_record'
+
+      class User < FakeActiveRecord
+        def name;  super end
+        def email; super end
+      end
+      """
+
+    When I run `rspec spec/user_spec.rb`
+    Then the examples should all pass

data/rspec-mocks/upstream/features/verifying_doubles/instance_doubles.feature

@@ -0,0 +1,101 @@
+Feature: Using an instance double
+
+  An `instance_double` is the most common type of verifying double. It takes a class name or
+  object as its first argument, then verifies that any methods being stubbed would be present
+  on an _instance_ of that class. If any argument matchers are specified, it also verifies that the
+  number of arguments is correct.
+
+  For methods handled by `method_missing`, see [dynamic classes](./dynamic-classes).
+
+  Background:
+    Given a file named "app/models/user.rb" with:
+      """ruby
+      class User < Struct.new(:notifier)
+        def suspend!
+          notifier.notify("suspended as")
+        end
+      end
+      """
+
+    Given a file named "spec/unit_helper.rb" with:
+      """ruby
+      $LOAD_PATH.unshift("app/models")
+      """
+
+    Given a file named "spec/spec_helper.rb" with:
+      """ruby
+      require 'unit_helper'
+
+      require 'user'
+      require 'console_notifier'
+
+      RSpec.configure do |config|
+        config.mock_with :rspec do |mocks|
+
+          # This option should be set when all dependencies are being loaded
+          # before a spec run, as is the case in a typical spec helper. It will
+          # cause any verifying double instantiation for a class that does not
+          # exist to raise, protecting against incorrectly spelt names.
+          mocks.verify_doubled_constant_names = true
+
+        end
+      end
+      """
+
+    Given a file named "spec/unit/user_spec.rb" with:
+      """ruby
+      require 'unit_helper'
+
+      require 'user'
+
+      RSpec.describe User, '#suspend!' do
+        it 'notifies the console' do
+          notifier = instance_double("ConsoleNotifier")
+
+          expect(notifier).to receive(:notify).with("suspended as")
+
+          user = User.new(notifier)
+          user.suspend!
+        end
+      end
+      """
+
+  Scenario: spec passes in isolation
+    When I run `rspec spec/unit/user_spec.rb`
+    Then the examples should all pass
+
+  Scenario: spec passes with dependencies loaded and method implemented
+    Given a file named "app/models/console_notifier.rb" with:
+      """ruby
+      class ConsoleNotifier
+        def notify(msg)
+          puts message
+        end
+      end
+      """
+
+    When I run `rspec -r./spec/spec_helper spec/unit/user_spec.rb`
+    Then the examples should all pass
+
+  Scenario: spec fails with dependencies loaded and method unimplemented
+    Given a file named "app/models/console_notifier.rb" with:
+      """ruby
+      class ConsoleNotifier
+      end
+      """
+    When I run `rspec -r./spec/spec_helper spec/unit/user_spec.rb`
+    Then the output should contain "1 example, 1 failure"
+    And the output should contain "ConsoleNotifier does not implement:"
+
+  Scenario: spec fails with dependencies loaded and incorrect arity
+    Given a file named "app/models/console_notifier.rb" with:
+      """ruby
+      class ConsoleNotifier
+        def notify(msg, color)
+          puts color + message
+        end
+      end
+      """
+    When I run `rspec -r./spec/spec_helper spec/unit/user_spec.rb`
+    Then the output should contain "1 example, 1 failure"
+    And the output should contain "Wrong number of arguments."