opal-rspec 0.6.2 → 0.7.0.rc.1

data/rspec-expectations/spec/rspec/matchers/built_in/all_spec.rb

@@ -1,212 +0,0 @@
-module RSpec::Matchers::BuiltIn
-  RSpec.describe All do
-
-    it_behaves_like 'an RSpec matcher', :valid_value => ['A', 'A', 'A'], :invalid_value => ['A', 'A', 'B'], :disallows_negation => true do
-      let(:matcher) { all( eq('A') ) }
-    end
-
-    describe 'description' do
-      it 'provides a description' do
-        matcher = all( eq('A') )
-        expect(matcher.description).to eq 'all eq "A"'
-      end
-    end
-
-    context 'when single matcher is given' do
-
-      describe 'expect(...).to all(expected)' do
-
-        it 'can pass' do
-          expect(['A', 'A', 'A']).to all( eq('A') )
-        end
-
-        describe 'failure message' do
-
-          context 'when the matcher has single-line failure message' do
-            it 'returns the index of the failed object' do
-              expect {
-                expect(['A', 'A', 'A', 5, 'A']).to all( be_a(String) )
-              }.to fail_with(dedent <<-EOS)
-              |expected ["A", "A", "A", 5, "A"] to all be a kind of String
-              |
-              |   object at index 3 failed to match:
-              |      expected 5 to be a kind of String
-              EOS
-            end
-
-            it 'returns the indexes of all failed objects, not just the first one' do
-              expect {
-                expect(['A', 'A', 'A', 5, 6]).to all( be_a(String) )
-              }.to fail_with(dedent <<-EOS)
-              |expected ["A", "A", "A", 5, 6] to all be a kind of String
-              |
-              |   object at index 3 failed to match:
-              |      expected 5 to be a kind of String
-              |
-              |   object at index 4 failed to match:
-              |      expected 6 to be a kind of String
-              EOS
-            end
-          end
-
-
-          context 'when the matcher has multi-line failure message' do
-            it 'returns the index of the failed object' do
-              expect {
-                expect(['A', 'A', 'A', 'C', 'A']).to all( eq('A') )
-              }.to fail_with(dedent <<-EOS)
-              |expected ["A", "A", "A", "C", "A"] to all eq "A"
-              |
-              |   object at index 3 failed to match:
-              |      expected: "A"
-              |           got: "C"
-              |
-              |      (compared using ==)
-              EOS
-            end
-
-            it 'returns the indexes of all failed objects, not just the first one' do
-              expect {
-                expect(['A', 'B', 'A', 'C', 'A']).to all( eq('A') )
-              }.to fail_with(dedent <<-EOS)
-              |expected ["A", "B", "A", "C", "A"] to all eq "A"
-              |
-              |   object at index 1 failed to match:
-              |      expected: "A"
-              |           got: "B"
-              |
-              |      (compared using ==)
-              |
-              |   object at index 3 failed to match:
-              |      expected: "A"
-              |           got: "C"
-              |
-              |      (compared using ==)
-              EOS
-            end
-          end
-
-        end
-      end
-    end
-
-    context 'when composed matcher is given' do
-
-      describe 'expect(...).to all(expected)' do
-        it 'can pass' do
-          expect([3, 4, 7, 8]).to all( be_between(2, 5).or be_between(6, 9) )
-        end
-      end
-
-      describe 'failure message' do
-
-        context 'when a single object fails' do
-          it 'returns the index of the failed object for the composed matcher' do
-            expect {
-              expect([3, 4, 7, 28]).to all( be_between(2, 5).or be_between(6, 9) )
-            }.to fail_with(dedent <<-EOS)
-              |expected [3, 4, 7, 28] to all be between 2 and 5 (inclusive) or be between 6 and 9 (inclusive)
-              |
-              |   object at index 3 failed to match:
-              |      expected 28 to be between 2 and 5 (inclusive) or expected 28 to be between 6 and 9 (inclusive)
-            EOS
-          end
-        end
-
-        context 'when a multiple objects fails' do
-          it 'returns the indexes of the failed objects for the composed matcher, not just the first one' do
-            expect {
-              expect([3, 4, 27, 22]).to all( be_between(2, 5).or be_between(6, 9) )
-            }.to fail_with(dedent <<-EOS)
-              |expected [3, 4, 27, 22] to all be between 2 and 5 (inclusive) or be between 6 and 9 (inclusive)
-              |
-              |   object at index 2 failed to match:
-              |      expected 27 to be between 2 and 5 (inclusive) or expected 27 to be between 6 and 9 (inclusive)
-              |
-              |   object at index 3 failed to match:
-              |      expected 22 to be between 2 and 5 (inclusive) or expected 22 to be between 6 and 9 (inclusive)
-            EOS
-          end
-        end
-      end
-    end
-
-    shared_examples "making a copy" do |copy_method|
-      context "when making a copy via `#{copy_method}`" do
-
-        let(:base_matcher) { eq(3) }
-        let(:all_matcher) { all( base_matcher ) }
-        let(:copied_matcher) { all_matcher.__send__(copy_method) }
-
-        it "uses a copy of the base matcher" do
-          expect(copied_matcher).not_to equal(all_matcher)
-          expect(copied_matcher.matcher).not_to equal(base_matcher)
-          expect(copied_matcher.matcher).to be_a(base_matcher.class)
-          expect(copied_matcher.matcher.expected).to eq(3)
-        end
-
-        context 'when using a custom matcher' do
-
-          let(:base_matcher) { custom_include(3) }
-
-          it 'copies custom matchers properly so they can work even though they have singleton behavior' do
-            expect(copied_matcher).not_to equal(all_matcher)
-            expect(copied_matcher.matcher).not_to equal(base_matcher)
-            expect([[3]]).to copied_matcher
-            expect { expect([[4]]).to copied_matcher }.to fail_matching("expected [4]")
-          end
-
-        end
-
-      end
-    end
-
-    include_examples 'making a copy', :clone
-    include_examples 'making a copy', :dup
-
-    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 {
-          expect(["foo", "bar", "a"]).to all( have_string_length(3) )
-        }.to fail
-      end
-
-      context "when passing a compound expression" do
-        it "works properly in spite of the memoization" do
-          expect {
-            expect(["foo", "bar", "a"]).to all( have_string_length(2).or have_string_length(3) )
-          }.to fail
-        end
-      end
-    end
-
-    context 'when the actual data does not define #each_with_index' do
-      let(:actual) { 5 }
-
-      it 'returns a failure message' do
-        expect {
-          expect(actual).to all(be_a(String))
-        }.to fail_with("expected #{actual.inspect} to all be a kind of String, but was not iterable")
-      end
-    end
-
-    context 'when the actual data does not include enumerable but defines #each_with_index' do
-      let(:actual) do
-        obj = Object.new
-        def obj.each_with_index(&block); [5].each_with_index { |o,i| yield(o,i) }; end
-        obj
-      end
-
-      it 'passes properly' do
-        expect(actual).to all(be_a(Integer))
-      end
-
-      it 'fails properly' do
-        expect {
-          expect(actual).to all(be_even)
-        }.to fail_with(/to all be even/)
-      end
-    end
-
-  end
-end

data/rspec-expectations/spec/rspec/matchers/built_in/base_matcher_spec.rb

@@ -1,140 +0,0 @@
-module RSpec::Matchers::BuiltIn
-  RSpec.describe BaseMatcher do
-    describe "#match_unless_raises" do
-      let(:matcher) do
-        Class.new(BaseMatcher).new
-      end
-
-      it "returns true if there are no errors" do
-        expect(matcher.match_unless_raises {}).to be_truthy
-      end
-
-      it "returns false if there is an error" do
-        expect(matcher.match_unless_raises { raise }).to be_falsey
-      end
-
-      it "returns false if the only submitted error is raised" do
-        expect(matcher.match_unless_raises(RuntimeError){ raise "foo" }).to be_falsey
-      end
-
-      it "returns false if any of several errors submitted is raised" do
-        expect(matcher.match_unless_raises(RuntimeError, ArgumentError, NameError) { raise "foo" }).to be_falsey
-        expect(matcher.match_unless_raises(RuntimeError, ArgumentError, NameError) { raise ArgumentError.new('') }).to be_falsey
-        expect(matcher.match_unless_raises(RuntimeError, ArgumentError, NameError) { raise NameError.new('') }).to be_falsey
-      end
-
-      it "re-raises any error other than one of those specified" do
-        expect do
-          matcher.match_unless_raises(ArgumentError){ raise "foo" }
-        end.to raise_error
-      end
-
-      it "stores the rescued exception for use in messages" do
-        matcher.match_unless_raises(RuntimeError){ raise "foo" }
-        expect(matcher.rescued_exception).to be_a(RuntimeError)
-        expect(matcher.rescued_exception.message).to eq("foo")
-      end
-
-    end
-
-    describe "#failure_message" do
-      context "when the parameter to .new is omitted" do
-        it "describes what was expected" do
-          matcher_class = Class.new(BaseMatcher) do
-            def name=(name)
-              @name = name
-            end
-
-            def match(expected, actual)
-              false
-            end
-          end
-
-          matcher = matcher_class.new
-          matcher.name = "be something"
-          matcher.matches?("foo")
-          expect(matcher.failure_message).to eq('expected "foo" to be something')
-        end
-      end
-    end
-
-    describe "#===" do
-      it "responds the same way as matches?" do
-        matcher = Class.new(BaseMatcher) do
-          def initialize(expected)
-            @expected = expected
-          end
-
-          def matches?(actual)
-            (@actual = actual) == @expected
-          end
-        end
-
-        expect(matcher.new(3).matches?(3)).to be_truthy
-        expect(matcher.new(3)).to be === 3
-
-        expect(matcher.new(3).matches?(4)).to be_falsey
-        expect(matcher.new(3)).not_to be === 4
-      end
-    end
-
-    describe "default failure message detection" do
-      def has_default_failure_messages?(matcher)
-        BaseMatcher::DefaultFailureMessages.has_default_failure_messages?(matcher)
-      end
-
-      shared_examples_for "detecting default failure message" do
-        context "that has no failure message overrides" do
-          it "indicates that it has default failure messages" do
-            matcher = build_matcher
-            expect(has_default_failure_messages?(matcher)).to be true
-          end
-        end
-
-        context "that overrides `failure_message`" do
-          it "indicates that it lacks default failure messages" do
-            matcher = build_matcher { def failure_message; end }
-            expect(has_default_failure_messages?(matcher)).to be false
-          end
-        end
-
-        context "that overrides `failure_message_when_negated`" do
-          it "indicates that it lacks default failure messages" do
-            matcher = build_matcher { def failure_message_when_negated; end }
-            expect(has_default_failure_messages?(matcher)).to be false
-          end
-        end
-      end
-
-      context "for a DSL-defined custom macher" do
-        include_examples "detecting default failure message" do
-          def build_matcher(&block)
-            definition = Proc.new do
-              match { }
-              module_exec(&block) if block
-            end
-
-            RSpec::Matchers::DSL::Matcher.new(:matcher_name, definition, self)
-          end
-        end
-      end
-
-      context "for a matcher that subclasses `BaseMatcher`" do
-        include_examples "detecting default failure message" do
-          def build_matcher(&block)
-            Class.new(RSpec::Matchers::BuiltIn::BaseMatcher, &block).new
-          end
-        end
-      end
-
-      context "for a custom matcher that lacks `failure_message_when_negated` (documented as an optional part of the matcher protocol" do
-        it "indicates that it lacks default failure messages" do
-          matcher = Class.new(RSpec::Matchers::BuiltIn::BaseMatcher) { undef failure_message_when_negated }.new
-
-          expect(RSpec::Support.is_a_matcher?(matcher)).to be true
-          expect(has_default_failure_messages?(matcher)).to be false
-        end
-      end
-    end
-  end
-end

data/rspec-expectations/spec/rspec/matchers/built_in/be_between_spec.rb

@@ -1,157 +0,0 @@
-module RSpec::Matchers::BuiltIn
-  RSpec.describe BeBetween do
-    class SizeMatters
-      include Comparable
-      attr :str
-      def <=>(other)
-        str.size <=> other.str.size
-      end
-      def initialize(str)
-        @str = str
-      end
-      def inspect
-        @str
-      end
-    end
-
-    shared_examples "be_between" do |mode|
-      it "passes if target is between min and max" do
-        expect(5).to matcher(1, 10)
-      end
-
-      it "fails if target is not between min and max" do
-        expect {
-          # It does not go to 11
-          expect(11).to matcher(1, 10)
-        }.to fail_with("expected 11 to be between 1 and 10 (#{mode})")
-      end
-
-      it "works with strings" do
-        expect("baz").to matcher("bar", "foo")
-
-        expect {
-          expect("foo").to matcher("bar", "baz")
-        }.to fail_with("expected \"foo\" to be between \"bar\" and \"baz\" (#{mode})")
-      end
-
-      it "works with other Comparable objects" do
-        expect(SizeMatters.new("--")).to matcher(SizeMatters.new("-"), SizeMatters.new("---"))
-
-        expect {
-          expect(SizeMatters.new("---")).to matcher(SizeMatters.new("-"), SizeMatters.new("--"))
-        }.to fail_with("expected --- to be between - and -- (#{mode})")
-      end
-    end
-
-    shared_examples "not_to be_between" do |mode|
-      it "passes if target is not between min and max" do
-        expect(11).not_to matcher(1, 10)
-      end
-
-      it "fails if target is between min and max" do
-        expect {
-          expect(5).not_to matcher(1, 10)
-        }.to fail_with("expected 5 not to be between 1 and 10 (#{mode})")
-      end
-    end
-
-    shared_examples "composing with other matchers" do |mode|
-      it "passes when the matchers both match" do
-        expect([nil, 3]).to include(matcher(2, 4), a_nil_value)
-      end
-
-      it "works with mixed types" do
-        expect(["baz", Math::PI]).to include(matcher(3.1, 3.2), matcher("bar", "foo"))
-
-        expect {
-          expect(["baz", 2.14]).to include(matcher(3.1, 3.2), matcher("bar", "foo") )
-        }.to fail_with("expected [\"baz\", 2.14] to include (a value between 3.1 and 3.2 (#{mode})) and (a value between \"bar\" and \"foo\" (#{mode}))")
-      end
-
-      it "provides a description" do
-        description = include(matcher(2, 4), an_instance_of(Float)).description
-        expect(description).to eq("include (a value between 2 and 4 (#{mode})) and (an instance of Float)")
-      end
-
-      it "fails with a clear error message when the matchers do not match" do
-        expect {
-          expect([nil, 1]).to include(matcher(2, 4), a_nil_value)
-        }.to fail_with("expected [nil, 1] to include (a value between 2 and 4 (#{mode})) and (a nil value)")
-      end
-    end
-
-    it_behaves_like "an RSpec matcher", :valid_value => (10), :invalid_value => (11) do
-      let(:matcher) { be_between(1, 10) }
-    end
-
-    describe "expect(...).to be_between(min, max) (inclusive)" do
-      it_behaves_like "be_between", :inclusive do
-        def matcher(min, max)
-          be_between(min, max)
-        end
-      end
-
-      it "is inclusive" do
-        expect(1).to be_between(1, 10)
-        expect(10).to be_between(1, 10)
-      end
-
-      it "indicates it was not comparable if it does not respond to `<=` and `>=`" do
-        expect {
-          expect(nil).to be_between(0, 10)
-        }.to fail_with("expected nil to be between 0 and 10 (inclusive), but it does not respond to `<=` and `>=`")
-      end
-    end
-
-    describe "expect(...).to be_between(min, max) (exclusive)" do
-      it_behaves_like "be_between", :exclusive do
-        def matcher(min, max)
-          be_between(min, max).exclusive
-        end
-      end
-
-      it "indicates it was not comparable if it does not respond to `<` and `>`" do
-        expect {
-          expect(nil).to be_between(0, 10).exclusive
-        }.to fail_with("expected nil to be between 0 and 10 (exclusive), but it does not respond to `<` and `>`")
-      end
-
-      it "is exclusive" do
-        expect { expect(1).to be_between(1, 10).exclusive }.to fail
-        expect { expect(10).to be_between(1, 10).exclusive }.to fail
-      end
-    end
-
-    describe "expect(...).not_to be_between(min, max) (inclusive)" do
-      it_behaves_like "not_to be_between", :inclusive do
-        def matcher(min, max)
-          be_between(min, max)
-        end
-      end
-    end
-
-    describe "expect(...).not_to be_between(min, max) (exclusive)" do
-      it_behaves_like "not_to be_between", :exclusive do
-        def matcher(min, max)
-          be_between(min, max).exclusive
-        end
-      end
-    end
-
-    describe "composing with other matchers (inclusive)" do
-      it_behaves_like "composing with other matchers", :inclusive do
-        def matcher(min, max)
-          a_value_between(min, max)
-        end
-      end
-    end
-
-    describe "composing with other matchers (exclusive)" do
-      it_behaves_like "composing with other matchers", :exclusive do
-        def matcher(min, max)
-          a_value_between(min, max).exclusive
-        end
-      end
-    end
-  end
-end