opal-rspec 0.6.2 → 0.7.0.rc.1

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

@@ -1,77 +0,0 @@
-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

@@ -1,199 +0,0 @@
-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

@@ -1,189 +0,0 @@
-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