opal-rspec 0.4.3 → 0.5.0.beta1

data/rspec-expectations/spec/rspec/expectations/handler_spec.rb

@@ -0,0 +1,200 @@
+module ExampleExpectations
+
+  class ArbitraryMatcher
+    def initialize(*args, &block)
+      if args.last.is_a? Hash
+        @expected = args.last[:expected]
+      end
+      @expected = block.call if block
+      @block = block
+    end
+
+    def matches?(target)
+      @target = target
+      return @expected == target
+    end
+
+    def with(new_value)
+      @expected = new_value
+      self
+    end
+
+    def failure_message
+      "expected #{@expected}, got #{@target}"
+    end
+
+    def failure_message_when_negated
+      "expected not #{@expected}, got #{@target}"
+    end
+  end
+
+  class PositiveOnlyMatcher < ArbitraryMatcher
+    undef failure_message_when_negated rescue nil
+  end
+
+  def arbitrary_matcher(*args, &block)
+    ArbitraryMatcher.new(*args, &block)
+  end
+
+  def positive_only_matcher(*args, &block)
+    PositiveOnlyMatcher.new(*args, &block)
+  end
+
+end
+
+module RSpec
+  module Expectations
+    RSpec.describe PositiveExpectationHandler do
+      include ExampleExpectations
+
+      it "handles submitted args" do
+        expect(5).to arbitrary_matcher(:expected => 5)
+        expect(5).to arbitrary_matcher(:expected => "wrong").with(5)
+        expect { expect(5).to arbitrary_matcher(:expected => 4) }.to fail_with("expected 4, got 5")
+        expect { expect(5).to arbitrary_matcher(:expected => 5).with(4) }.to fail_with("expected 4, got 5")
+        expect(5).not_to arbitrary_matcher(:expected => 4)
+        expect(5).not_to arbitrary_matcher(:expected => 5).with(4)
+        expect { expect(5).not_to arbitrary_matcher(:expected => 5) }.to fail_with("expected not 5, got 5")
+        expect { expect(5).not_to arbitrary_matcher(:expected => 4).with(5) }.to fail_with("expected not 5, got 5")
+      end
+
+      it "handles the submitted block" do
+        expect(5).to arbitrary_matcher { 5 }
+        expect(5).to arbitrary_matcher(:expected => 4) { 5 }
+        expect(5).to arbitrary_matcher(:expected => 4).with(5) { 3 }
+      end
+
+      describe "#handle_matcher" do
+        it "asks the matcher if it matches" do
+          matcher = double("matcher")
+          actual = Object.new
+          expect(matcher).to receive(:matches?).with(actual).and_return(true)
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
+        end
+
+        it "returns the match value" do
+          matcher = double("matcher")
+          actual = Object.new
+          expect(matcher).to receive(:matches?).with(actual).and_return(:this_value)
+          expect(RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)).to eq :this_value
+        end
+
+        it "calls failure_message if the matcher implements it" do
+          matcher = double("matcher", :failure_message => "message", :matches? => false)
+          actual = Object.new
+
+          expect(::RSpec::Expectations).to receive(:fail_with).with("message")
+
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
+        end
+
+        it "calls fail if matcher.diffable?" do
+          matcher = double("matcher",
+            :diffable? => true,
+            :failure_message => "message",
+            :matches? => false,
+            :expected => 1,
+            :actual   => 2
+          )
+          actual = Object.new
+
+          expect(::RSpec::Expectations).to receive(:fail_with).with("message", 1, 2)
+
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
+        end
+
+        it "calls failure_message if the matcher does not implement failure_message" do
+          matcher = double("matcher", :failure_message => "message", :matches? => false)
+          actual = Object.new
+
+          expect(::RSpec::Expectations).to receive(:fail_with).with("message")
+
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
+
+        end
+
+        it "uses the custom failure message when one is provided" do
+          matcher = double("matcher", :failure_message => "message", :matches? => false)
+          actual = Object.new
+
+          expect(::RSpec::Expectations).to receive(:fail_with).with("custom")
+
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher, "custom")
+        end
+
+        it "uses the custom failure message when one is provided as a callable object" do
+          matcher = double("matcher", :failure_message => "message", :matches? => false)
+          actual = Object.new
+
+          failure_message = double("failure message", :call => "custom")
+
+          expect(::RSpec::Expectations).to receive(:fail_with).with("custom")
+
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher, failure_message)
+        end
+      end
+    end
+
+    RSpec.describe NegativeExpectationHandler do
+      describe "#handle_matcher" do
+        it "asks the matcher if it doesn't match when the matcher responds to #does_not_match?" do
+          matcher = double("matcher", :does_not_match? => true, :failure_message_when_negated => nil)
+          actual = Object.new
+          expect(matcher).to receive(:does_not_match?).with(actual).and_return(true)
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
+        end
+
+        it "asks the matcher if it matches when the matcher doesn't respond to #does_not_match?" do
+          matcher = double("matcher")
+          actual = Object.new
+          allow(matcher).to receive(:failure_message_when_negated)
+          expect(matcher).to receive(:matches?).with(actual).and_return(false)
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
+        end
+
+        it "returns the match value" do
+          matcher = double("matcher")
+          actual = Object.new
+          expect(matcher).to receive(:matches?).with(actual).and_return(false)
+          allow(matcher).to receive(:failure_message_when_negated).and_return("ignore")
+          expect(RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)).to be_falsey
+        end
+
+        it "calls fail if matcher.diffable?" do
+          matcher = double("matcher",
+            :diffable? => true,
+            :failure_message_when_negated => "message",
+            :matches? => true,
+            :expected => 1,
+            :actual   => 2
+          )
+          actual = Object.new
+
+          expect(::RSpec::Expectations).to receive(:fail_with).with("message", 1, 2)
+
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
+        end
+
+        it "uses the custom failure message when one is provided" do
+          matcher = double("matcher", :failure_message_when_negated => "message", :matches? => true)
+          actual = Object.new
+
+          expect(::RSpec::Expectations).to receive(:fail_with).with("custom")
+
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher, "custom")
+        end
+
+        it "uses the custom failure message when one is provided as a callable object" do
+          matcher = double("matcher", :failure_message_when_negated => "message", :matches? => true)
+          actual = Object.new
+
+          failure_message = double("failure message", :call => "custom")
+
+          expect(::RSpec::Expectations).to receive(:fail_with).with("custom")
+
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher, failure_message)
+        end
+      end
+    end
+  end
+end

data/rspec-expectations/spec/rspec/expectations/minitest_integration_spec.rb

@@ -0,0 +1,25 @@
+module RSpec
+  RSpec.describe Matchers do
+
+    let(:sample_matchers) do
+      [:be,
+       :be_instance_of,
+       :be_kind_of]
+    end
+
+    context "once required", :slow do
+      include MinitestIntegration
+
+      it "includes itself in Minitest::Test" do
+        with_minitest_loaded do
+          minitest_case = MiniTest::Test.allocate
+          sample_matchers.each do |sample_matcher|
+              expect(minitest_case).to respond_to(sample_matcher)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/rspec-expectations/spec/rspec/expectations/syntax_spec.rb

@@ -0,0 +1,93 @@
+module RSpec
+  module Expectations
+    RSpec.describe Syntax do
+      context "when passing a message to an expectation" do
+        let(:warner) { ::Kernel }
+
+        let(:string_like_object) do
+          Struct.new(:to_str, :to_s).new(*(["Ceci n'est pas une Chaine."]*2))
+        end
+
+        let(:insufficiently_string_like_object) do
+          Struct.new(:to_s).new("Ceci n'est pas une Chaine.")
+        end
+
+        let(:callable_object) do
+          Struct.new(:call).new("Ceci n'est pas une Chaine.")
+        end
+
+        describe "expect(...).to" do
+          it "prints a warning when the message object isn't a String" do
+            expect(warner).to receive(:warn).with(/ignoring.*message/)
+            expect(3).to eq(3), :not_a_string
+          end
+
+          it "doesn't print a warning when message is a String" do
+            expect(warner).not_to receive(:warn)
+            expect(3).to eq(3), "a string"
+          end
+
+          it "doesn't print a warning when message responds to to_str" do
+            expect(warner).not_to receive(:warn)
+            expect(3).to eq(3), string_like_object
+          end
+
+          it "prints a warning when the message object handles to_s but not to_str" do
+            expect(warner).to receive(:warn).with(/ignoring.*message/)
+            expect(3).to eq(3), insufficiently_string_like_object
+          end
+
+          it "doesn't print a warning when message responds to call" do
+            expect(warner).not_to receive(:warn)
+            expect(3).to eq(3), callable_object
+          end
+        end
+
+        describe "expect(...).not_to" do
+          it "prints a warning when the message object isn't a String" do
+            expect(warner).to receive(:warn).with(/ignoring.*message/)
+            expect(3).not_to eq(4), :not_a_string
+          end
+
+          it "doesn't print a warning when message is a String" do
+            expect(warner).not_to receive(:warn)
+            expect(3).not_to eq(4), "a string"
+          end
+
+          it "doesn't print a warning when message responds to to_str" do
+            expect(warner).not_to receive(:warn)
+            expect(3).not_to eq(4), string_like_object
+          end
+
+          it "prints a warning when the message object handles to_s but not to_str" do
+            expect(warner).to receive(:warn).with(/ignoring.*message/)
+            expect(3).not_to eq(4), insufficiently_string_like_object
+          end
+
+          it "doesn't print a warning when message responds to call" do
+            expect(warner).not_to receive(:warn)
+            expect(3).not_to eq(4), callable_object
+          end
+        end
+      end
+
+      describe "enabling the should syntax on something other than the default syntax host" do
+        include_context "with the default expectation syntax"
+
+        it "continues to warn about the should syntax" do
+          my_host = Class.new
+          expect(RSpec).to receive(:deprecate)
+          Syntax.enable_should(my_host)
+
+          3.should eq 3
+        end
+      end
+    end
+  end
+
+  RSpec.describe Expectations do
+    it "does not inadvertently define BasicObject on 1.8", :if => RUBY_VERSION.to_f < 1.9 do
+      expect(defined?(::BasicObject)).to be nil
+    end
+  end
+end

data/rspec-expectations/spec/rspec/expectations_spec.rb

@@ -0,0 +1,15 @@
+require 'rspec/support/spec/prevent_load_time_warnings'
+
+RSpec.describe "RSpec::Expectations" do
+  it_behaves_like 'a library that issues no warnings when loaded', 'rspec-expectations',
+    # We define minitest constants because rspec/expectations/minitest_integration
+    # expects these constants to already be defined.
+    'module Minitest; class Assertion; end; module Test; end; end',
+    'require "rspec/expectations"'
+
+  it 'does not allow expectation failures to be caught by a bare rescue' do
+    expect {
+      expect(2).to eq(3) rescue nil
+    }.to fail_matching("expected: 3")
+  end
+end

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

@@ -0,0 +1,113 @@
+module RSpec
+  module Matchers
+    RSpec.describe AliasedMatcher do
+      RSpec::Matchers.define :my_base_matcher do
+        match { |actual| actual == foo }
+
+        def foo
+          13
+        end
+
+        def description
+          "my base matcher description"
+        end
+      end
+      RSpec::Matchers.alias_matcher :alias_of_my_base_matcher, :my_base_matcher
+
+      it_behaves_like "an RSpec matcher", :valid_value => 13, :invalid_value => nil do
+        let(:matcher) { alias_of_my_base_matcher }
+      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 = AliasedMatcher.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_matcher
+            aliased = AliasedMatcher.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(13).to copy
+
+            expect { expect(15).to copy }.to fail_with(/expected 15/)
+          end
+        end
+      end
+
+      include_examples "making a copy", :dup
+      include_examples "making a copy", :clone
+
+      it 'can get a method object for delegated methods', :if => (RUBY_VERSION.to_f > 1.8) do
+        matcher = my_base_matcher
+        decorated = AliasedMatcher.new(matcher, Proc.new { })
+
+        expect(decorated.method(:foo).call).to eq(13)
+      end
+
+      it 'can get a method object for `description`' do
+        matcher = my_base_matcher
+        decorated = AliasedMatcher.new(matcher, Proc.new { "overriden description" })
+
+        expect(decorated.method(:description).call).to eq("overriden description")
+      end
+
+      RSpec::Matchers.alias_matcher :my_overriden_matcher, :my_base_matcher do |desc|
+        desc + " (overriden)"
+      end
+
+      it 'overrides the description with the provided block' do
+        matcher = my_overriden_matcher
+        expect(matcher.description).to eq("my base matcher description (overriden)")
+      end
+
+      RSpec::Matchers.alias_matcher :my_blockless_override, :my_base_matcher
+
+      it 'provides a default description override based on the old and new games' do
+        matcher = my_blockless_override
+        expect(matcher.description).to eq("my blockless override description")
+      end
+
+      RSpec::Matchers.define_negated_matcher :avoid_outputting, :output
+
+      it 'works properly with a chained method off a negated matcher' do
+        expect { }.to avoid_outputting.to_stdout
+
+        expect {
+          expect { $stdout.puts "a" }.to avoid_outputting.to_stdout
+        }.to fail
+      end
+
+      context "when negating a matcher that does not define `description` (which is an optional part of the matcher protocol)" do
+        def matcher_without_description
+          matcher = Object.new
+          def matcher.matches?(v); v; end
+          def matcher.failure_message; "match failed"; end
+          def matcher.chained; self; end
+          expect(RSpec::Matchers.is_a_matcher?(matcher)).to be true
+
+          matcher
+        end
+
+        RSpec::Matchers.define_negated_matcher :negation_of_matcher_without_description, :matcher_without_description
+
+        it 'works properly' do
+          expect(true).to matcher_without_description.chained
+          expect(false).to negation_of_matcher_without_description.chained
+        end
+      end
+    end
+  end
+end
+