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

data/rspec-expectations/upstream/features/built_in_matchers/be_within.feature

@@ -0,0 +1,48 @@
+Feature: `be_within` matcher
+
+  Normal equality expectations do not work well for floating point values.
+  Consider this irb session:
+
+      > radius = 3
+        => 3
+      > area_of_circle = radius * radius * Math::PI
+        => 28.2743338823081
+      > area_of_circle == 28.2743338823081
+        => false
+
+  Instead, you should use the be_within matcher to check that the value is within a delta of
+  your expected value:
+
+    ```ruby
+    expect(area_of_circle).to be_within(0.1).of(28.3)
+    ```
+
+  Note that the difference between the actual and expected values must be smaller than your
+  delta; if it is equal, the matcher will fail.
+
+  Scenario: basic usage
+    Given a file named "be_within_matcher_spec.rb" with:
+      """ruby
+      RSpec.describe 27.5 do
+        it { is_expected.to be_within(0.5).of(27.9) }
+        it { is_expected.to be_within(0.5).of(28.0) }
+        it { is_expected.to be_within(0.5).of(27.1) }
+        it { is_expected.to be_within(0.5).of(27.0) }
+
+        it { is_expected.not_to be_within(0.5).of(28.1) }
+        it { is_expected.not_to be_within(0.5).of(26.9) }
+
+        # deliberate failures
+        it { is_expected.not_to be_within(0.5).of(28) }
+        it { is_expected.not_to be_within(0.5).of(27) }
+        it { is_expected.to be_within(0.5).of(28.1) }
+        it { is_expected.to be_within(0.5).of(26.9) }
+      end
+      """
+    When I run `rspec be_within_matcher_spec.rb`
+    Then the output should contain all of these:
+      | 10 examples, 4 failures                     |
+      | expected 27.5 not to be within 0.5 of 28   |
+      | expected 27.5 not to be within 0.5 of 27   |
+      | expected 27.5 to be within 0.5 of 28.1     |
+      | expected 27.5 to be within 0.5 of 26.9     |

data/rspec-expectations/upstream/features/built_in_matchers/change.feature

@@ -0,0 +1,66 @@
+Feature: `change` matcher
+
+  The `change` matcher is used to specify that a block of code changes some mutable state.
+  You can specify what will change using either of two forms:
+
+  * `expect { do_something }.to change(object, :attribute)`
+  * `expect { do_something }.to change { object.attribute }`
+
+  You can further qualify the change by chaining `from` and/or `to` or one of `by`, `by_at_most`,
+  `by_at_least`.
+
+  Background:
+    Given a file named "lib/counter.rb" with:
+      """ruby
+      class Counter
+        class << self
+          def increment
+            @count ||= 0
+            @count += 1
+          end
+
+          def count
+            @count ||= 0
+          end
+        end
+      end
+      """
+
+  Scenario: expect change
+    Given a file named "spec/example_spec.rb" with:
+      """ruby
+      require "counter"
+
+      RSpec.describe Counter, "#increment" do
+        it "should increment the count" do
+          expect { Counter.increment }.to change{Counter.count}.from(0).to(1)
+        end
+
+        # deliberate failure
+        it "should increment the count by 2" do
+          expect { Counter.increment }.to change{Counter.count}.by(2)
+        end
+      end
+      """
+    When I run `rspec spec/example_spec.rb`
+    Then the output should contain "1 failure"
+    Then the output should contain "expected result to have changed by 2, but was changed by 1"
+
+  Scenario: expect no change
+    Given a file named "spec/example_spec.rb" with:
+      """ruby
+      require "counter"
+
+      RSpec.describe Counter, "#increment" do
+        it "should not increment the count by 1 (using not_to)" do
+          expect { Counter.increment }.not_to change{Counter.count}
+        end
+
+        it "should not increment the count by 1 (using to_not)" do
+          expect { Counter.increment }.to_not change{Counter.count}
+        end
+      end
+      """
+    When I run `rspec spec/example_spec.rb`
+    Then the output should contain "2 failures"
+    Then the output should contain "expected result not to have changed, but did change from 1 to 2"

data/rspec-expectations/upstream/features/built_in_matchers/comparisons.feature

@@ -0,0 +1,96 @@
+Feature: Comparison matchers
+
+  RSpec provides a number of matchers that are based on Ruby's built-in operators. These
+  can be used for generalized comparison of values. E.g.
+
+    ```ruby
+    expect(9).to be > 6
+    expect(3).to be <= 3
+    expect(1).to be < 6
+    ```
+
+  Scenario: numeric operator matchers
+    Given a file named "numeric_operator_matchers_spec.rb" with:
+      """ruby
+      RSpec.describe 18 do
+        it { is_expected.to be < 20 }
+        it { is_expected.to be > 15 }
+        it { is_expected.to be <= 19 }
+        it { is_expected.to be >= 17 }
+
+        # deliberate failures
+        it { is_expected.to be < 15 }
+        it { is_expected.to be > 20 }
+        it { is_expected.to be <= 17 }
+        it { is_expected.to be >= 19 }
+      end
+      """
+     When I run `rspec numeric_operator_matchers_spec.rb`
+     Then the output should contain "8 examples, 4 failures"
+      And the output should contain:
+      """
+           Failure/Error: it { is_expected.to be < 15 }
+             expected: < 15
+                  got:   18
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { is_expected.to be > 20 }
+             expected: > 20
+                  got:   18
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { is_expected.to be <= 17 }
+             expected: <= 17
+                  got:    18
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { is_expected.to be >= 19 }
+             expected: >= 19
+                  got:    18
+      """
+
+  Scenario: string operator matchers
+    Given a file named "string_operator_matchers_spec.rb" with:
+      """ruby
+      RSpec.describe "Strawberry" do
+        it { is_expected.to be < "Tomato" }
+        it { is_expected.to be > "Apple" }
+        it { is_expected.to be <= "Turnip" }
+        it { is_expected.to be >= "Banana" }
+
+        # deliberate failures
+        it { is_expected.to be < "Cranberry" }
+        it { is_expected.to be > "Zuchini" }
+        it { is_expected.to be <= "Potato" }
+        it { is_expected.to be >= "Tomato" }
+      end
+      """
+     When I run `rspec string_operator_matchers_spec.rb`
+     Then the output should contain "8 examples, 4 failures"
+      And the output should contain:
+      """
+           Failure/Error: it { is_expected.to be < "Cranberry" }
+             expected: < "Cranberry"
+                  got:   "Strawberry"
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { is_expected.to be > "Zuchini" }
+             expected: > "Zuchini"
+                  got:   "Strawberry"
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { is_expected.to be <= "Potato" }
+             expected: <= "Potato"
+                  got:    "Strawberry"
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { is_expected.to be >= "Tomato" }
+             expected: >= "Tomato"
+                  got:    "Strawberry"
+      """

data/rspec-expectations/upstream/features/built_in_matchers/contain_exactly.feature

@@ -0,0 +1,64 @@
+Feature: `contain_exactly` matcher
+
+  The `contain_exactly` matcher provides a way to test arrays against each other in a way
+  that disregards differences in the ordering between the actual and expected array.
+  For example:
+
+    ```ruby
+    expect([1, 2, 3]).to    contain_exactly(2, 3, 1) # pass
+    expect([:a, :c, :b]).to contain_exactly(:a, :c ) # fail
+    ```
+
+  This matcher is also available as `match_array`, which expects the expected array to be
+  given as a single array argument rather than as individual splatted elements. The above
+  could also be written as:
+
+    ```ruby
+    expect([1, 2, 3]).to    match_array [2, 3, 1] # pass
+    expect([:a, :c, :b]).to match_array [:a, :c]  # fail
+    ```
+
+  Scenario: Array is expected to contain every value
+    Given a file named "contain_exactly_matcher_spec.rb" with:
+      """ruby
+      RSpec.describe [1, 2, 3] do
+        it { is_expected.to contain_exactly(1, 2, 3) }
+        it { is_expected.to contain_exactly(1, 3, 2) }
+        it { is_expected.to contain_exactly(2, 1, 3) }
+        it { is_expected.to contain_exactly(2, 3, 1) }
+        it { is_expected.to contain_exactly(3, 1, 2) }
+        it { is_expected.to contain_exactly(3, 2, 1) }
+
+        # deliberate failures
+        it { is_expected.to contain_exactly(1, 2, 1) }
+      end
+      """
+     When I run `rspec contain_exactly_matcher_spec.rb`
+     Then the output should contain "7 examples, 1 failure"
+      And the output should contain:
+      """
+           Failure/Error: it { is_expected.to contain_exactly(1, 2, 1) }
+             expected collection contained:  [1, 1, 2]
+             actual collection contained:    [1, 2, 3]
+             the missing elements were:      [1]
+             the extra elements were:        [3]
+      """
+
+  Scenario: Array is not expected to contain every value
+    Given a file named "contain_exactly_matcher_spec.rb" with:
+      """ruby
+      RSpec.describe [1, 2, 3] do
+        it { is_expected.to_not contain_exactly(1, 2, 3, 4) }
+        it { is_expected.to_not contain_exactly(1, 2) }
+
+        # deliberate failures
+        it { is_expected.to_not contain_exactly(1, 3, 2) }
+      end
+      """
+     When I run `rspec contain_exactly_matcher_spec.rb`
+     Then the output should contain "3 examples, 1 failure"
+      And the output should contain:
+      """
+           Failure/Error: it { is_expected.to_not contain_exactly(1, 3, 2) }
+             expected [1, 2, 3] not to contain exactly 1, 3, and 2
+      """

data/rspec-expectations/upstream/features/built_in_matchers/cover.feature

@@ -0,0 +1,47 @@
+@ruby-1.9
+Feature: `cover` matcher
+
+  Use the cover matcher to specify that a range covers one or more
+  expected objects. This works on any object that responds to #cover?
+  (such as a Range):
+
+    ```ruby
+    expect(1..10).to cover(5)
+    expect(1..10).to cover(4, 6)
+    expect(1..10).not_to cover(11)
+    ```
+
+  Scenario: range usage
+    Given a file named "range_cover_matcher_spec.rb" with:
+      """ruby
+      RSpec.describe (1..10) do
+        it { is_expected.to cover(4) }
+        it { is_expected.to cover(6) }
+        it { is_expected.to cover(8) }
+        it { is_expected.to cover(4, 6) }
+        it { is_expected.to cover(4, 6, 8) }
+        it { is_expected.not_to cover(11) }
+        it { is_expected.not_to cover(11, 12) }
+
+        # deliberate failures
+        it { is_expected.to cover(11) }
+        it { is_expected.not_to cover(4) }
+        it { is_expected.not_to cover(6) }
+        it { is_expected.not_to cover(8) }
+        it { is_expected.not_to cover(4, 6, 8) }
+
+        # both of these should fail since it covers 5 but not 11
+        it { is_expected.to cover(5, 11) }
+        it { is_expected.not_to cover(5, 11) }
+      end
+      """
+    When I run `rspec range_cover_matcher_spec.rb`
+    Then the output should contain all of these:
+      | 14 examples, 7 failures                 |
+      | expected 1..10 to cover 11              |
+      | expected 1..10 not to cover 4           |
+      | expected 1..10 not to cover 6           |
+      | expected 1..10 not to cover 8           |
+      | expected 1..10 not to cover 4, 6, and 8 |
+      | expected 1..10 to cover 5 and 11        |
+      | expected 1..10 not to cover 5 and 11    |

data/rspec-expectations/upstream/features/built_in_matchers/end_with.feature

@@ -0,0 +1,48 @@
+Feature: `end_with` matcher
+
+  Use the `end_with` matcher to specify that a string or array ends with the expected
+  characters or elements.
+
+    ```ruby
+    expect("this string").to end_with "string"
+    expect("this string").not_to end_with "stringy"
+    expect([0, 1, 2]).to end_with 1, 2
+    ```
+
+  Scenario: string usage
+    Given a file named "example_spec.rb" with:
+      """ruby
+      RSpec.describe "this string" do
+        it { is_expected.to end_with "string" }
+        it { is_expected.not_to end_with "stringy" }
+
+        # deliberate failures
+        it { is_expected.not_to end_with "string" }
+        it { is_expected.to end_with "stringy" }
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain all of these:
+      | 4 examples, 2 failures                          |
+      | expected "this string" not to end with "string" |
+      | expected "this string" to end with "stringy"    |
+
+  Scenario: array usage
+    Given a file named "example_spec.rb" with:
+      """ruby
+      RSpec.describe [0, 1, 2, 3, 4] do
+        it { is_expected.to end_with 4 }
+        it { is_expected.to end_with 3, 4 }
+        it { is_expected.not_to end_with 3 }
+        it { is_expected.not_to end_with 0, 1, 2, 3, 4, 5 }
+
+        # deliberate failures
+        it { is_expected.not_to end_with 4 }
+        it { is_expected.to end_with 3 }
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain all of these:
+      | 6 examples, 2 failures                     |
+      | expected [0, 1, 2, 3, 4] not to end with 4 |
+      | expected [0, 1, 2, 3, 4] to end with 3     |

data/rspec-expectations/upstream/features/built_in_matchers/equality.feature

@@ -0,0 +1,135 @@
+Feature: Equality matchers
+
+  Ruby exposes several different methods for handling equality:
+
+      a.equal?(b) # object identity - a and b refer to the same object
+      a.eql?(b)   # object equivalence - a and b have the same value
+      a == b      # object equivalence - a and b have the same value with type conversions
+
+  Note that these descriptions are guidelines but are not forced by the language. Any object
+  can implement any of these methods with its own semantics.
+
+  rspec-expectations ships with matchers that align with each of these methods:
+
+    ```ruby
+    expect(a).to equal(b) # passes if a.equal?(b)
+    expect(a).to eql(b)   # passes if a.eql?(b)
+    expect(a).to be == b  # passes if a == b
+    ```
+
+  It also ships with two matchers that have more of a DSL feel to them:
+
+    ```ruby
+    expect(a).to be(b) # passes if a.equal?(b)
+    expect(a).to eq(b) # passes if a == b
+    ```
+
+  Scenario: compare using eq (==)
+    Given a file named "compare_using_eq.rb" with:
+      """ruby
+      RSpec.describe "a string" do
+        it "is equal to another string of the same value" do
+          expect("this string").to eq("this string")
+        end
+
+        it "is not equal to another string of a different value" do
+          expect("this string").not_to eq("a different string")
+        end
+      end
+
+      RSpec.describe "an integer" do
+        it "is equal to a float of the same value" do
+          expect(5).to eq(5.0)
+        end
+      end
+      """
+    When I run `rspec compare_using_eq.rb`
+    Then the output should contain "3 examples, 0 failures"
+
+  Scenario: compare using ==
+    Given a file named "compare_using_==.rb" with:
+      """ruby
+      RSpec.describe "a string" do
+        it "is equal to another string of the same value" do
+          expect("this string").to be == "this string"
+        end
+
+        it "is not equal to another string of a different value" do
+          expect("this string").not_to be == "a different string"
+        end
+      end
+
+      RSpec.describe "an integer" do
+        it "is equal to a float of the same value" do
+          expect(5).to be == 5.0
+        end
+      end
+      """
+    When I run `rspec compare_using_==.rb`
+    Then the output should contain "3 examples, 0 failures"
+
+  Scenario: compare using eql (eql?)
+    Given a file named "compare_using_eql.rb" with:
+      """ruby
+      RSpec.describe "an integer" do
+        it "is equal to another integer of the same value" do
+          expect(5).to eql(5)
+        end
+
+        it "is not equal to another integer of a different value" do
+          expect(5).not_to eql(6)
+        end
+
+        it "is not equal to a float of the same value" do
+          expect(5).not_to eql(5.0)
+        end
+
+      end
+      """
+    When I run `rspec compare_using_eql.rb`
+    Then the output should contain "3 examples, 0 failures"
+
+  Scenario: compare using equal (equal?)
+    Given a file named "compare_using_equal.rb" with:
+      """ruby
+      RSpec.describe "a string" do
+        it "is equal to itself" do
+          string = "this string"
+          expect(string).to equal(string)
+        end
+
+        it "is not equal to another string of the same value" do
+          expect("this string").not_to equal("this string")
+        end
+
+        it "is not equal to another string of a different value" do
+          expect("this string").not_to equal("a different string")
+        end
+
+      end
+      """
+    When I run `rspec compare_using_equal.rb`
+    Then the output should contain "3 examples, 0 failures"
+
+  Scenario: compare using be (equal?)
+    Given a file named "compare_using_be.rb" with:
+      """ruby
+      RSpec.describe "a string" do
+        it "is equal to itself" do
+          string = "this string"
+          expect(string).to be(string)
+        end
+
+        it "is not equal to another string of the same value" do
+          expect("this string").not_to be("this string")
+        end
+
+        it "is not equal to another string of a different value" do
+          expect("this string").not_to be("a different string")
+        end
+
+      end
+      """
+    When I run `rspec compare_using_be.rb`
+    Then the output should contain "3 examples, 0 failures"
+