opal-rspec 0.4.3 → 0.5.0.beta1

data/rspec-expectations/spec/rspec/matchers/composable_spec.rb

@@ -0,0 +1,77 @@
+module RSpec
+  module Matchers
+    RSpec.describe Composable do
+      RSpec::Matchers.define :matcher_using_surface_descriptions_in do |expected|
+        match { false }
+        failure_message { surface_descriptions_in(expected) }
+      end
+
+      it "does not blow up when surfacing descriptions from an unreadable IO object" do
+        expect {
+          expect(3).to matcher_using_surface_descriptions_in(STDOUT)
+        }.to fail_with(STDOUT.inspect)
+      end
+
+      it "doesn't mangle struct descriptions" do
+        model = Struct.new(:a).new(1)
+        expect {
+          expect(1).to matcher_using_surface_descriptions_in(model)
+        }.to fail_with(model.inspect)
+      end
+
+      RSpec::Matchers.define :all_but_one do |matcher|
+        match do |actual|
+          match_count = actual.count { |v| values_match?(matcher, v) }
+          actual.size == match_count + 1
+        end
+      end
+
+      context "when using a matcher instance that memoizes state multiple times in a composed expression" do
+        it "works properly in spite of the memoization" do
+          expect(["foo", "bar", "a"]).to all_but_one(have_string_length(3))
+        end
+
+        context "when passing a compound expression" do
+          it "works properly in spite of the memoization" do
+            expect(["A", "AB", "ABC"]).to all_but_one(
+                have_string_length(1).or have_string_length(2)
+            )
+          end
+        end
+      end
+
+      describe "cloning data structures containing matchers" do
+        include Composable
+
+        it "clones only the contained matchers" do
+          matcher_1   = eq(1)
+          matcher_2   = eq(2)
+          object      = Object.new
+          uncloneable = nil
+
+          data_structure = {
+            "foo"  => matcher_1,
+            "bar"  => [matcher_2, uncloneable],
+            "bazz" => object
+          }
+
+          cloned = with_matchers_cloned(data_structure)
+          expect(cloned).not_to equal(data_structure)
+
+          expect(cloned["foo"]).to be_a_clone_of(matcher_1)
+          expect(cloned["bar"].first).to be_a_clone_of(matcher_2)
+          expect(cloned["bazz"]).to equal(object)
+        end
+
+        it "copies custom matchers properly so they can work even though they have singleton behavior" do
+          expect("foo").to with_matchers_cloned(have_string_length 3)
+        end
+
+        it 'does not blow up when passed an array containing an IO object' do
+          stdout = STDOUT
+          expect(with_matchers_cloned([stdout]).first).to equal(stdout)
+        end
+      end
+    end
+  end
+end

data/rspec-expectations/spec/rspec/matchers/define_negated_matcher_spec.rb

@@ -0,0 +1,199 @@
+module RSpec
+  module Matchers
+    RSpec.describe 'RSpec::Matchers.define_negated_matcher' do
+      RSpec::Matchers.define :my_base_non_negated_matcher do
+        match { |actual| actual == foo }
+
+        def foo
+          13
+        end
+
+        def description
+          "my base matcher description"
+        end
+      end
+
+      shared_examples "making a copy" do |copy_method|
+        context "when making a copy via `#{copy_method}`" do
+          it "uses a copy of the base matcher" do
+            base_matcher = include(3)
+            aliased = AliasedNegatedMatcher.new(base_matcher, Proc.new {})
+            copy = aliased.__send__(copy_method)
+
+            expect(copy).not_to equal(aliased)
+            expect(copy.base_matcher).not_to equal(base_matcher)
+            expect(copy.base_matcher).to be_a(RSpec::Matchers::BuiltIn::Include)
+            expect(copy.base_matcher.expected).to eq([3])
+          end
+
+          it "copies custom matchers properly so they can work even though they have singleton behavior" do
+            base_matcher = my_base_non_negated_matcher
+            aliased = AliasedNegatedMatcher.new(base_matcher, Proc.new { |a| a })
+            copy = aliased.__send__(copy_method)
+
+            expect(copy).not_to equal(aliased)
+            expect(copy.base_matcher).not_to equal(base_matcher)
+
+            expect(15).to copy
+
+            expect { expect(13).to copy }.to fail_with(/expected 13/)
+          end
+        end
+      end
+
+      include_examples "making a copy", :dup
+      include_examples "making a copy", :clone
+
+      RSpec::Matchers.define_negated_matcher :an_array_excluding, :include
+      it_behaves_like "an RSpec matcher", :valid_value => [1, 3], :invalid_value => [1, 2] do
+        let(:matcher) { an_array_excluding(2) }
+      end
+
+      it 'works properly when composed' do
+        list = 1.upto(10).to_a
+        expect { list.delete(5) }.to change { list }.to(an_array_excluding 5)
+      end
+
+      describe "the failure message" do
+        context "for a matcher with default failure messages" do
+          RSpec::Matchers.define(:be_awesome) { match(&:awesome?) }
+          RSpec::Matchers.define_negated_matcher :be_lame, :be_awesome
+
+          context "when failing positively" do
+            it "uses the phrasing from the provided defined matcher alias" do
+              expect {
+                expect(double(:awesome? => true, :inspect => "<Object>")).to be_lame
+              }.to fail_with("expected <Object> to be lame")
+            end
+          end
+
+          context "when failing negatively" do
+            it "uses the phrasing from the provided defined matcher alias" do
+              expect {
+                expect(double(:awesome? => false, :inspect => "<Object>")).not_to be_lame
+              }.to fail_with("expected <Object> not to be lame")
+            end
+          end
+
+          context "when accessed via an alias that is not included in failure messages" do
+            alias_method :be_fantastic, :be_awesome
+            RSpec::Matchers.define_negated_matcher :be_terrible, :be_fantastic
+
+            context "when failing positively" do
+              it "uses the wrapped matcher's `failure_message_when_negated`" do
+                expect {
+                  expect(double(:awesome? => true, :inspect => "<Object>")).to be_terrible
+                }.to fail_with("expected <Object> not to be awesome")
+              end
+            end
+
+            context "when failing negatively" do
+              it "uses the wrapped matcher's `failure_message`" do
+                expect {
+                  expect(double(:awesome? => false, :inspect => "<Object>")).not_to be_terrible
+                }.to fail_with("expected <Object> to be awesome")
+              end
+            end
+          end
+        end
+
+        context "for a matcher with a customized `failure_message_when_negated`" do
+          RSpec::Matchers.define(:be_tall) do
+            match(&:tall?)
+            failure_message_when_negated do |actual|
+              "expected #{actual.inspect} not to be tall, but was tall"
+            end
+          end
+          RSpec::Matchers.define_negated_matcher :be_short, :be_tall
+
+          context "when failing positively" do
+            it "uses the wrapped matcher's `failure_message_when_negated` since it may include more detail" do
+              expect {
+                expect(double(:tall? => true, :inspect => "<Object>")).to be_short
+              }.to fail_with("expected <Object> not to be tall, but was tall")
+            end
+          end
+
+          context "when failing negatively" do
+            it "uses the wrapped matcher's `failure_message` since it may include more detail" do
+              expect {
+                expect(double(:tall? => false, :inspect => "<Object>")).not_to be_short
+              }.to fail_with("expected <Object> to be tall")
+            end
+          end
+        end
+      end
+
+      context 'when no block is passed' do
+        RSpec::Matchers.define :be_an_odd_number do
+          match { |actual| actual.odd? }
+        end
+        RSpec::Matchers.define_negated_matcher :be_an_even_number, :be_an_odd_number
+
+        it 'uses the default negated description' do
+          expect(be_an_even_number.description).to eq("be an even number")
+        end
+
+        context "when matched positively" do
+          it 'matches values that fail the original matcher' do
+            expect { expect(22).to be_an_odd_number }.to fail_with("expected 22 to be an odd number")
+            expect(22).to be_an_even_number
+          end
+
+          it "fails matches against values that pass the original matcher" do
+            expect(21).to be_an_odd_number
+            expect { expect(21).to be_an_even_number }.to fail_with("expected 21 to be an even number")
+          end
+        end
+
+        context "when matched negatively" do
+          it 'matches values that fail the original matcher' do
+            expect { expect(21).not_to be_an_odd_number }.to fail_with("expected 21 not to be an odd number")
+            expect(21).not_to be_an_even_number
+          end
+
+          it "fails matches against values that pass the original matcher" do
+            expect(22).not_to be_an_odd_number
+            expect { expect(22).not_to be_an_even_number }.to fail_with("expected 22 not to be an even number")
+          end
+        end
+      end
+
+      context 'when the negated description is overriden' do
+        RSpec::Matchers.define :be_bigger_than_ten do
+          match { |actual| actual > 10 }
+        end
+        RSpec::Matchers.define_negated_matcher :be_smaller_than_ten, :be_bigger_than_ten do |desc|
+          "#{desc.sub('bigger', 'smaller')} (overriden)"
+        end
+
+        it 'overrides the description with the provided block' do
+          expect(be_smaller_than_ten.description).to eq("be smaller than ten (overriden)")
+        end
+
+        it 'overrides the failure message with the provided block' do
+          expect { expect(12).to be_smaller_than_ten }.to fail_with("expected 12 to be smaller than ten (overriden)")
+        end
+      end
+
+      context "for a matcher that has custom `match_when_negated` logic" do
+        RSpec::Matchers.define :matcher_with_custom_negation do |match_value|
+          match { match_value }
+          match_when_negated { |actual| actual == :does_not_match_true }
+        end
+        RSpec::Matchers.define_negated_matcher :negated_matcher_with_custom_negation, :matcher_with_custom_negation
+
+        it "uses the `match_when_negated` logic for matching" do
+          expect(:does_not_match_true).to negated_matcher_with_custom_negation(true)
+          expect {
+            expect(:does_not_match_false).to negated_matcher_with_custom_negation(true)
+          }.to fail
+        end
+
+        it "uses the `match` logic for `expect(..).not_to`" do
+          expect(:foo).not_to negated_matcher_with_custom_negation(true)
+        end
+      end
+    end
+  end
+end

data/rspec-expectations/spec/rspec/matchers/description_generation_spec.rb

@@ -0,0 +1,189 @@
+RSpec.describe "Matchers should be able to generate their own descriptions" do
+  after(:example) do
+    RSpec::Matchers.clear_generated_description
+  end
+
+  it "expect(...).to eq expected" do
+    expect("this").to eq "this"
+    expect(RSpec::Matchers.generated_description).to eq "should eq \"this\""
+  end
+
+  it "expect(...).to not eq expected" do
+    expect("this").not_to eq "that"
+    expect(RSpec::Matchers.generated_description).to eq "should not eq \"that\""
+  end
+
+  it "expect(...).to be empty (arbitrary predicate)" do
+    expect([]).to be_empty
+    expect(RSpec::Matchers.generated_description).to eq "should be empty"
+  end
+
+  it "expect(...).to not be empty (arbitrary predicate)" do
+    expect([1]).not_to be_empty
+    expect(RSpec::Matchers.generated_description).to eq "should not be empty"
+  end
+
+  it "expect(...).to be truthy" do
+    expect(true).to be_truthy
+    expect(RSpec::Matchers.generated_description).to eq "should be truthy"
+  end
+
+  it "expect(...).to be falsey" do
+    expect(false).to be_falsey
+    expect(RSpec::Matchers.generated_description).to eq "should be falsey"
+  end
+
+  it "expect(...).to be nil" do
+    expect(nil).to be_nil
+    expect(RSpec::Matchers.generated_description).to eq "should be nil"
+  end
+
+  it "expect(...).to be > n" do
+    expect(5).to be > 3
+    expect(RSpec::Matchers.generated_description).to eq "should be > 3"
+  end
+
+  it "expect(...).to be between min and max" do
+    expect(10).to be_between(0, 10)
+    expect(RSpec::Matchers.generated_description).to eq "should be between 0 and 10 (inclusive)"
+  end
+
+  it "expect(...).to be exclusively between min and max" do
+    expect(9).to be_between(0, 10).exclusive
+    expect(RSpec::Matchers.generated_description).to eq "should be between 0 and 10 (exclusive)"
+  end
+
+  it "expect(...).to be predicate arg1, arg2 and arg3" do
+    class Parent; end
+    class Child < Parent
+      def child_of?(*parents)
+        parents.all? { |parent| self.is_a?(parent) }
+      end
+    end
+    expect(Child.new).to be_a_child_of(Parent, Object)
+    expect(RSpec::Matchers.generated_description).to eq "should be a child of Parent and Object"
+  end
+
+  it "expect(...).to equal" do
+    expected = "expected"
+    expect(expected).to equal(expected)
+    expect(RSpec::Matchers.generated_description).to eq "should equal \"expected\""
+  end
+
+  it "expect(...).not_to equal" do
+    expect(5).not_to equal(37)
+    expect(RSpec::Matchers.generated_description).to eq "should not equal 37"
+  end
+
+  it "expect(...).to eql" do
+    expect("string").to eql("string")
+    expect(RSpec::Matchers.generated_description).to eq "should eql \"string\""
+  end
+
+  it "expect(...).not_to eql" do
+    expect("a").not_to eql(:a)
+    expect(RSpec::Matchers.generated_description).to eq "should not eql :a"
+  end
+
+  it "expect(...).to have_key" do
+    expect({:a => "a"}).to have_key(:a)
+    expect(RSpec::Matchers.generated_description).to eq "should have key :a"
+  end
+
+  it "expect(...).to have_some_method" do
+    object = Object.new
+    def object.has_eyes_closed?; true; end
+
+    expect(object).to have_eyes_closed
+    expect(RSpec::Matchers.generated_description).to eq 'should have eyes closed'
+  end
+
+  it "expect(...).to have_some_method(args*)" do
+    object = Object.new
+    def object.has_taste_for?(*args); true; end
+
+    expect(object).to have_taste_for("wine", "cheese")
+    expect(RSpec::Matchers.generated_description).to eq 'should have taste for "wine", "cheese"'
+  end
+
+  it "expect(...).to include(x)" do
+    expect([1,2,3]).to include(3)
+    expect(RSpec::Matchers.generated_description).to eq "should include 3"
+  end
+
+  it "expect(...).to include(x) when x responds to description but is not a matcher" do
+    obj = double(:description => "description", :inspect => "inspect")
+    expect([obj]).to include(obj)
+    expect(RSpec::Matchers.generated_description).to eq "should include inspect"
+  end
+
+  it "expect(...).to include(x) when x responds to description and is a matcher" do
+    matcher = double(:description                => "description",
+                     :matches?                   => true,
+                     :failure_message => "")
+    expect([matcher]).to include(matcher)
+    expect(RSpec::Matchers.generated_description).to eq "should include (description)"
+  end
+
+  it "expect(array).to contain_exactly(1, 2, 3)" do
+    expect([1,2,3]).to contain_exactly(1, 2, 3)
+    expect(RSpec::Matchers.generated_description).to eq "should contain exactly 1, 2, and 3"
+  end
+
+  it "expect(...).to match" do
+    expect("this string").to match(/this string/)
+    expect(RSpec::Matchers.generated_description).to eq "should match /this string/"
+  end
+
+  it "expect(...).to raise_error" do
+    expect { raise }.to raise_error
+    expect(RSpec::Matchers.generated_description).to eq "should raise Exception"
+  end
+
+  it "expect(...).to raise_error with type" do
+    expect { raise }.to raise_error(RuntimeError)
+    expect(RSpec::Matchers.generated_description).to eq "should raise RuntimeError"
+  end
+
+  it "expect(...).to raise_error with type and message" do
+    expect { raise "there was an error" }.to raise_error(RuntimeError, "there was an error")
+    expect(RSpec::Matchers.generated_description).to eq "should raise RuntimeError with \"there was an error\""
+  end
+
+  it "expect(...).to respond_to" do
+    expect([]).to respond_to(:insert)
+    expect(RSpec::Matchers.generated_description).to eq "should respond to #insert"
+  end
+
+  it "expect(...).to throw symbol" do
+    expect { throw :what_a_mess }.to throw_symbol
+    expect(RSpec::Matchers.generated_description).to eq "should throw a Symbol"
+  end
+
+  it "expect(...).to throw symbol (with named symbol)" do
+    expect { throw :what_a_mess }.to throw_symbol(:what_a_mess)
+    expect(RSpec::Matchers.generated_description).to eq "should throw :what_a_mess"
+  end
+
+  def team
+    Class.new do
+      def players
+        [1,2,3]
+      end
+    end.new
+  end
+end
+
+RSpec.describe "a Matcher with no description" do
+  def matcher
+     Class.new do
+       def matches?(ignore); true; end
+       def failure_message; ""; end
+     end.new
+  end
+
+  it "provides a helpful message when used in a string-less example block" do
+    expect(5).to matcher
+    expect(RSpec::Matchers.generated_description).to match(/When you call.*description method/m)
+  end
+end