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

data/rspec-expectations/upstream/features/custom_matchers/access_running_example.feature

@@ -0,0 +1,48 @@
+Feature: access running example
+
+  In the context of a custom matcher, you can call helper methods that are available from the
+  current example's example group. This is used, for example, by rspec-rails in order to wrap
+  rails' built-in assertions (which depend on helper methods available in the test context).
+
+  Scenario: call method defined on example from matcher
+    Given a file named "example_spec.rb" with:
+      """ruby
+      RSpec::Matchers.define :bar do
+        match do |_|
+          foo == "foo"
+        end
+      end
+
+      RSpec.describe "something" do
+        def foo
+          "foo"
+        end
+
+        it "does something" do
+          expect("foo").to bar
+        end
+      end
+      """
+    When I run `rspec ./example_spec.rb`
+    Then the output should contain "1 example, 0 failures"
+
+  Scenario: call method _not_ defined on example from matcher
+    Given a file named "example_spec.rb" with:
+      """ruby
+      RSpec::Matchers.define :bar do
+        match do |_|
+          foo == "foo"
+        end
+      end
+
+      RSpec.describe "something" do
+        it "does something" do
+          expect("foo").to bar
+        end
+      end
+      """
+    When I run `rspec ./example_spec.rb`
+    Then the output should contain "1 example, 1 failure"
+    And the output should match /undefined.*method/
+    And the output should contain "RSpec::Matchers::DSL::Matcher"
+    And the output should not contain "ExampleGroup"

data/rspec-expectations/upstream/features/custom_matchers/define_diffable_matcher.feature

@@ -0,0 +1,29 @@
+Feature: define diffable matcher
+
+  When a matcher is defined as diffable, the output will include a diff of the submitted
+  objects when the objects are more than simple primitives.
+
+  Scenario: define a diffable matcher
+    Given a file named "diffable_matcher_spec.rb" with:
+      """ruby
+      RSpec::Matchers.define :be_just_like do |expected|
+        match do |actual|
+          actual == expected
+        end
+
+        diffable
+      end
+
+      RSpec.describe "two\nlines" do
+        it { is_expected.to be_just_like("three\nlines") }
+      end
+      """
+    When I run `rspec ./diffable_matcher_spec.rb`
+    Then it should fail with:
+      """
+             Diff:
+             @@ -1,3 +1,3 @@
+             -three
+             +two
+              lines
+      """

data/rspec-expectations/upstream/features/custom_matchers/define_matcher.feature

@@ -0,0 +1,337 @@
+Feature: define matcher
+
+  rspec-expectations provides a DSL for defining custom matchers. These are often useful for
+  expressing expectations in the domain of your application.
+
+  Scenario: define a matcher with default messages
+    Given a file named "matcher_with_default_message_spec.rb" with:
+      """ruby
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        match do |actual|
+          actual % expected == 0
+        end
+      end
+
+      RSpec.describe 9 do
+        it { is_expected.to be_a_multiple_of(3) }
+      end
+
+      RSpec.describe 9 do
+        it { is_expected.not_to be_a_multiple_of(4) }
+      end
+
+      # fail intentionally to generate expected output
+      RSpec.describe 9 do
+        it { is_expected.to be_a_multiple_of(4) }
+      end
+
+      # fail intentionally to generate expected output
+      RSpec.describe 9 do
+        it { is_expected.not_to be_a_multiple_of(3) }
+      end
+      """
+    When I run `rspec ./matcher_with_default_message_spec.rb --format documentation`
+    Then the exit status should not be 0
+
+    And the output should contain "should be a multiple of 3"
+    And the output should contain "should not be a multiple of 4"
+    And the output should contain "Failure/Error: it { is_expected.to be_a_multiple_of(4) }"
+    And the output should contain "Failure/Error: it { is_expected.not_to be_a_multiple_of(3) }"
+
+    And the output should contain "4 examples, 2 failures"
+    And the output should contain "expected 9 to be a multiple of 4"
+    And the output should contain "expected 9 not to be a multiple of 3"
+
+  Scenario: overriding the failure_message
+    Given a file named "matcher_with_failure_message_spec.rb" with:
+      """ruby
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        match do |actual|
+          actual % expected == 0
+        end
+        failure_message do |actual|
+          "expected that #{actual} would be a multiple of #{expected}"
+        end
+      end
+
+      # fail intentionally to generate expected output
+      RSpec.describe 9 do
+        it { is_expected.to be_a_multiple_of(4) }
+      end
+      """
+    When I run `rspec ./matcher_with_failure_message_spec.rb`
+    Then the exit status should not be 0
+    And the stdout should contain "1 example, 1 failure"
+    And the stdout should contain "expected that 9 would be a multiple of 4"
+
+  Scenario: overriding the failure_message_when_negated
+    Given a file named "matcher_with_failure_for_message_spec.rb" with:
+      """ruby
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        match do |actual|
+          actual % expected == 0
+        end
+        failure_message_when_negated do |actual|
+          "expected that #{actual} would not be a multiple of #{expected}"
+        end
+      end
+
+      # fail intentionally to generate expected output
+      RSpec.describe 9 do
+        it { is_expected.not_to be_a_multiple_of(3) }
+      end
+      """
+    When I run `rspec ./matcher_with_failure_for_message_spec.rb`
+    Then the exit status should not be 0
+    And the stdout should contain "1 example, 1 failure"
+    And the stdout should contain "expected that 9 would not be a multiple of 3"
+
+  Scenario: overriding the description
+    Given a file named "matcher_overriding_description_spec.rb" with:
+      """ruby
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        match do |actual|
+          actual % expected == 0
+        end
+        description do
+          "be multiple of #{expected}"
+        end
+      end
+
+      RSpec.describe 9 do
+        it { is_expected.to be_a_multiple_of(3) }
+      end
+
+      RSpec.describe 9 do
+        it { is_expected.not_to be_a_multiple_of(4) }
+      end
+      """
+    When I run `rspec ./matcher_overriding_description_spec.rb --format documentation`
+    Then the exit status should be 0
+    And the stdout should contain "2 examples, 0 failures"
+    And the stdout should contain "should be multiple of 3"
+    And the stdout should contain "should not be multiple of 4"
+
+  Scenario: with no args
+    Given a file named "matcher_with_no_args_spec.rb" with:
+      """ruby
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :have_7_fingers do
+        match do |thing|
+          thing.fingers.length == 7
+        end
+      end
+
+      class Thing
+        def fingers; (1..7).collect {"finger"}; end
+      end
+
+      RSpec.describe Thing do
+        it { is_expected.to have_7_fingers }
+      end
+      """
+    When I run `rspec ./matcher_with_no_args_spec.rb --format documentation`
+    Then the exit status should be 0
+    And the stdout should contain "1 example, 0 failures"
+    And the stdout should contain "should have 7 fingers"
+
+  Scenario: with multiple args
+    Given a file named "matcher_with_multiple_args_spec.rb" with:
+      """ruby
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :be_the_sum_of do |a,b,c,d|
+        match do |sum|
+          a + b + c + d == sum
+        end
+      end
+
+      RSpec.describe 10 do
+        it { is_expected.to be_the_sum_of(1,2,3,4) }
+      end
+      """
+    When I run `rspec ./matcher_with_multiple_args_spec.rb --format documentation`
+    Then the exit status should be 0
+    And the stdout should contain "1 example, 0 failures"
+    And the stdout should contain "should be the sum of 1, 2, 3, and 4"
+
+  Scenario: with helper methods
+    Given a file named "matcher_with_internal_helper_spec.rb" with:
+      """ruby
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :have_same_elements_as do |sample|
+        match do |actual|
+          similar?(sample, actual)
+        end
+
+        def similar?(a, b)
+          a.sort == b.sort
+        end
+      end
+
+      RSpec.describe "these two arrays" do
+        specify "should be similar" do
+          expect([1,2,3]).to have_same_elements_as([2,3,1])
+        end
+      end
+      """
+    When I run `rspec ./matcher_with_internal_helper_spec.rb`
+    Then the exit status should be 0
+    And the stdout should contain "1 example, 0 failures"
+
+  Scenario: scoped in a module
+    Given a file named "scoped_matcher_spec.rb" with:
+      """ruby
+      require 'rspec/expectations'
+
+      module MyHelpers
+        extend RSpec::Matchers::DSL
+
+        matcher :be_just_like do |expected|
+          match {|actual| actual == expected}
+        end
+      end
+
+      RSpec.describe "group with MyHelpers" do
+        include MyHelpers
+        it "has access to the defined matcher" do
+          expect(5).to be_just_like(5)
+        end
+      end
+
+      RSpec.describe "group without MyHelpers" do
+        it "does not have access to the defined matcher" do
+          expect do
+            expect(5).to be_just_like(5)
+          end.to raise_exception
+        end
+      end
+      """
+
+    When I run `rspec ./scoped_matcher_spec.rb`
+    Then the stdout should contain "2 examples, 0 failures"
+
+  Scenario: scoped in an example group
+    Given a file named "scoped_matcher_spec.rb" with:
+      """ruby
+      require 'rspec/expectations'
+
+      RSpec.describe "group with matcher" do
+        matcher :be_just_like do |expected|
+          match {|actual| actual == expected}
+        end
+
+        it "has access to the defined matcher" do
+          expect(5).to be_just_like(5)
+        end
+
+        describe "nested group" do
+          it "has access to the defined matcher" do
+            expect(5).to be_just_like(5)
+          end
+        end
+      end
+
+      RSpec.describe "group without matcher" do
+        it "does not have access to the defined matcher" do
+          expect do
+            expect(5).to be_just_like(5)
+          end.to raise_exception
+        end
+      end
+      """
+
+    When I run `rspec scoped_matcher_spec.rb`
+    Then the output should contain "3 examples, 0 failures"
+
+  Scenario: matcher with separate logic for should and should_not
+    Given a file named "matcher_with_separate_should_not_logic_spec.rb" with:
+      """ruby
+      RSpec::Matchers.define :contain do |*expected|
+        match do |actual|
+          expected.all? { |e| actual.include?(e) }
+        end
+
+        match_when_negated do |actual|
+          expected.none? { |e| actual.include?(e) }
+        end
+      end
+
+      RSpec.describe [1, 2, 3] do
+        it { is_expected.to contain(1, 2) }
+        it { is_expected.not_to contain(4, 5, 6) }
+
+        # deliberate failures
+        it { is_expected.to contain(1, 4) }
+        it { is_expected.not_to contain(1, 4) }
+      end
+      """
+    When I run `rspec matcher_with_separate_should_not_logic_spec.rb`
+    Then the output should contain all of these:
+      | 4 examples, 2 failures                    |
+      | expected [1, 2, 3] to contain 1 and 4     |
+      | expected [1, 2, 3] not to contain 1 and 4 |
+
+  Scenario: use define_method to create a helper method with access to matcher params
+    Given a file named "define_method_spec.rb" with:
+      """ruby
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        define_method :is_multiple? do |actual|
+          actual % expected == 0
+        end
+        match { |actual| is_multiple?(actual) }
+      end
+
+      RSpec.describe 9 do
+        it { is_expected.to be_a_multiple_of(3) }
+        it { is_expected.not_to be_a_multiple_of(4) }
+
+        # deliberate failures
+        it { is_expected.to be_a_multiple_of(2) }
+        it { is_expected.not_to be_a_multiple_of(3) }
+      end
+      """
+    When I run `rspec define_method_spec.rb`
+    Then the output should contain all of these:
+      | 4 examples, 2 failures               |
+      | expected 9 to be a multiple of 2     |
+      | expected 9 not to be a multiple of 3 |
+
+  Scenario: include a module with helper methods in the matcher
+    Given a file named "include_module_spec.rb" with:
+      """ruby
+      module MatcherHelpers
+        def is_multiple?(actual, expected)
+          actual % expected == 0
+        end
+      end
+
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        include MatcherHelpers
+        match { |actual| is_multiple?(actual, expected) }
+      end
+
+      RSpec.describe 9 do
+        it { is_expected.to be_a_multiple_of(3) }
+        it { is_expected.not_to be_a_multiple_of(4) }
+
+        # deliberate failures
+        it { is_expected.to be_a_multiple_of(2) }
+        it { is_expected.not_to be_a_multiple_of(3) }
+      end
+      """
+    When I run `rspec include_module_spec.rb`
+    Then the output should contain all of these:
+      | 4 examples, 2 failures               |
+      | expected 9 to be a multiple of 2     |
+      | expected 9 not to be a multiple of 3 |

data/rspec-expectations/upstream/features/custom_matchers/define_matcher_outside_rspec.feature

@@ -0,0 +1,32 @@
+Feature: define matcher outside rspec
+
+  You can define custom matchers when using rspec-expectations outside of rspec-core.
+
+  Scenario: define a matcher with default messages
+    Given a file named "test_multiples.rb" with:
+      """ruby
+      require "minitest/autorun"
+      require "rspec/expectations/minitest_integration"
+
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        match do |actual|
+          actual % expected == 0
+        end
+      end
+
+      class TestMultiples < Minitest::Test
+
+        def test_9_should_be_a_multiple_of_3
+          expect(9).to be_a_multiple_of(3)
+        end
+
+        def test_9_should_be_a_multiple_of_4
+          expect(9).to be_a_multiple_of(4)
+        end
+
+      end
+      """
+    When I run `ruby test_multiples.rb`
+    Then the exit status should not be 0
+    And the output should contain "expected 9 to be a multiple of 4"
+    And the output should contain "2 runs, 2 assertions, 1 failures, 0 errors"

data/rspec-expectations/upstream/features/custom_matchers/define_matcher_with_fluent_interface.feature

@@ -0,0 +1,51 @@
+Feature: define matcher with fluent interface
+
+  Use the `chain` method to define matchers with a fluent interface.
+
+  Scenario: chained method with argument
+    Given a file named "between_spec.rb" with:
+      """ruby
+      RSpec::Matchers.define :be_bigger_than do |first|
+        match do |actual|
+          (actual > first) && (actual < @second)
+        end
+
+        chain :and_smaller_than do |second|
+          @second = second
+        end
+      end
+
+      RSpec.describe 5 do
+        it { is_expected.to be_bigger_than(4).and_smaller_than(6) }
+      end
+      """
+    When I run `rspec between_spec.rb --format documentation`
+    Then the output should contain "1 example, 0 failures"
+    And  the output should contain "should be bigger than 4"
+
+    Scenario: include_chain_clauses_in_custom_matcher_descriptions configured to true, and chained method with argument
+      Given a file named "between_spec.rb" with:
+        """ruby
+        RSpec.configure do |config|
+          config.expect_with :rspec do |c|
+            c.include_chain_clauses_in_custom_matcher_descriptions = true
+          end
+        end
+
+        RSpec::Matchers.define :be_bigger_than do |first|
+          match do |actual|
+            (actual > first) && (actual < @second)
+          end
+
+          chain :and_smaller_than do |second|
+            @second = second
+          end
+        end
+
+        RSpec.describe 5 do
+          it { is_expected.to be_bigger_than(4).and_smaller_than(6) }
+        end
+        """
+      When I run `rspec between_spec.rb --format documentation`
+      Then the output should contain "1 example, 0 failures"
+      And  the output should contain "should be bigger than 4 and smaller than 6"