opal-rspec 0.4.3 → 0.5.0.beta1

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

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

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

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

@@ -0,0 +1,61 @@
+module RSpec
+  module Matchers
+    [:be_an_instance_of, :be_instance_of].each do |method|
+      RSpec.describe "expect(actual).to #{method}(expected)" do
+        it_behaves_like "an RSpec matcher", :valid_value => 5, :invalid_value => "a" do
+          let(:matcher) { send(method, Fixnum) }
+        end
+
+        it "passes if actual is instance of expected class" do
+          expect(5).to send(method, Fixnum)
+        end
+
+        it "fails if actual is instance of subclass of expected class" do
+          expect {
+            expect(5).to send(method, Numeric)
+          }.to fail_with(%Q{expected 5 to be an instance of Numeric})
+        end
+
+        it "fails with failure message for should unless actual is instance of expected class" do
+          expect {
+            expect("foo").to send(method, Array)
+          }.to fail_with(%Q{expected "foo" to be an instance of Array})
+        end
+
+        it "provides a description" do
+          matcher = be_an_instance_of(Fixnum)
+          matcher.matches?(Numeric)
+          expect(matcher.description).to eq "be an instance of Fixnum"
+        end
+
+        context "when expected provides an expanded inspect, e.g. AR::Base" do
+          let(:user_klass) do
+            Class.new do
+              def self.inspect
+                "User(id: integer, name: string)"
+              end
+            end
+          end
+
+          before { stub_const("User", user_klass) }
+
+          it "provides a description including only the class name" do
+            matcher = be_an_instance_of(User)
+            expect(matcher.description).to eq "be an instance of User"
+          end
+        end
+      end
+
+      RSpec.describe "expect(actual).not_to #{method}(expected)" do
+
+        it "fails with failure message for should_not if actual is instance of expected class" do
+          expect {
+            expect("foo").not_to send(method, String)
+          }.to fail_with(%Q{expected "foo" not to be an instance of String})
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module RSpec
+  module Matchers
+    [:be_a_kind_of, :be_kind_of].each do |method|
+      RSpec.describe "expect(actual).to #{method}(expected)" do
+        it_behaves_like "an RSpec matcher", :valid_value => 5, :invalid_value => "a" do
+          let(:matcher) { send(method, Fixnum) }
+        end
+
+        it "passes if actual is instance of expected class" do
+          expect(5).to send(method, Fixnum)
+        end
+
+        it "passes if actual is instance of subclass of expected class" do
+          expect(5).to send(method, Numeric)
+        end
+
+        it "fails with failure message for should unless actual is kind of expected class" do
+          expect {
+            expect("foo").to send(method, Array)
+          }.to fail_with(%Q{expected "foo" to be a kind of Array})
+        end
+
+        it "provides a description" do
+          matcher = be_a_kind_of(String)
+          matcher.matches?("this")
+          expect(matcher.description).to eq "be a kind of String"
+        end
+      end
+
+      RSpec.describe "expect(actual).not_to #{method}(expected)" do
+        it "fails with failure message for should_not if actual is kind of expected class" do
+          expect {
+            expect("foo").not_to send(method, String)
+          }.to fail_with(%Q{expected "foo" not to be a kind of String})
+        end
+      end
+    end
+  end
+end