opal-rspec 0.4.3 → 0.5.0.beta1

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

@@ -0,0 +1,226 @@
+require 'delegate'
+
+module RSpec
+  module Expectations
+    RSpec.describe Configuration do
+      let(:config) { Configuration.new }
+
+      describe "#backtrace_formatter" do
+        let(:original_backtrace) { %w[ clean-me/a.rb other/file.rb clean-me/b.rb ] }
+        let(:cleaned_backtrace)  { %w[ other/file.rb ] }
+
+        let(:formatted_backtrace) do
+          config.backtrace_formatter.format_backtrace(original_backtrace)
+        end
+
+        before do
+          @old_patterns = RSpec.configuration.backtrace_exclusion_patterns
+          @orig_full_backtrace = RSpec.configuration.full_backtrace?
+          RSpec.configuration.full_backtrace = false
+          RSpec.configuration.backtrace_exclusion_patterns = [/clean-me/]
+        end
+
+        after do
+          RSpec.configuration.backtrace_exclusion_patterns = @old_patterns
+          RSpec.configuration.full_backtrace = @orig_full_backtrace
+        end
+
+        it "defaults to rspec-core's backtrace formatter when rspec-core is loaded" do
+          expect(config.backtrace_formatter).to be(RSpec.configuration.backtrace_formatter)
+          expect(formatted_backtrace).to eq(cleaned_backtrace)
+        end
+
+        it "defaults to a null formatter when rspec-core is not loaded" do
+          RSpec::Mocks.with_temporary_scope do
+            rspec_dup = ::RSpec.dup
+            class << rspec_dup; undef configuration; end
+            stub_const("RSpec", rspec_dup)
+
+            expect(formatted_backtrace).to eq(original_backtrace)
+          end
+        end
+
+        it "can be set to another backtrace formatter" do
+          config.backtrace_formatter = double(:format_backtrace => ['a'])
+          expect(formatted_backtrace).to eq(['a'])
+        end
+      end
+
+      context 'on an interpreter that does not provide BasicObject', :uses_should, :unless => defined?(::BasicObject) do
+        before { RSpec::Expectations::Syntax.disable_should(Delegator) }
+
+        let(:klass) do
+          Class.new(SimpleDelegator) do
+            def delegated?; true; end
+          end
+        end
+
+        let(:instance) { klass.new(Object.new) }
+
+        it 'provides a means to manually add it Delegator' do
+          instance.should_not respond_to(:delegated?) # because #should is being delegated...
+          config.add_should_and_should_not_to Delegator
+          instance.should respond_to(:delegated?) # now it should work!
+        end
+      end
+
+      describe "#include_chain_clauses_in_custom_matcher_descriptions?" do
+        it "is false by default" do
+          expect(config.include_chain_clauses_in_custom_matcher_descriptions?).to be false
+        end
+
+        it "can be set to true" do
+          config.include_chain_clauses_in_custom_matcher_descriptions = true
+          expect(config.include_chain_clauses_in_custom_matcher_descriptions?).to be true
+        end
+
+        it "can be set back to false" do
+          config.include_chain_clauses_in_custom_matcher_descriptions = true
+          config.include_chain_clauses_in_custom_matcher_descriptions = false
+          expect(config.include_chain_clauses_in_custom_matcher_descriptions?).to be false
+        end
+      end
+
+      shared_examples "configuring the expectation syntax" do
+        before do
+          @orig_syntax = RSpec::Matchers.configuration.syntax
+        end
+
+        after do
+          configure_syntax(@orig_syntax)
+        end
+
+        it 'can limit the syntax to :should' do
+          configure_syntax :should
+          configured_syntax.should eq([:should])
+
+          3.should eq(3)
+          3.should_not eq(4)
+          lambda { expect(6).to eq(6) }.should raise_error(NameError)
+        end
+
+        it 'is a no-op when configured to :should twice' do
+          configure_syntax :should
+          method_added_count = 0
+          allow(Expectations::Syntax.default_should_host).to receive(:method_added) { method_added_count += 1 }
+          configure_syntax :should
+
+          method_added_count.should eq(0)
+        end
+
+        it 'can limit the syntax to :expect' do
+          configure_syntax :expect
+          expect(configured_syntax).to eq([:expect])
+
+          expect(3).to eq(3)
+          expect { 3.should eq(3) }.to raise_error(NameError)
+          expect { 3.should_not eq(3) }.to raise_error(NameError)
+        end
+
+        it 'is a no-op when configured to :expect twice' do
+          allow(RSpec::Matchers).to receive(:method_added).and_raise("no methods should be added here")
+
+          configure_syntax :expect
+          configure_syntax :expect
+        end
+
+        describe "`:should` being enabled by default deprecation" do
+          before { configure_default_syntax }
+
+          it "warns when the should syntax is called by default" do
+            expected_arguments = [
+              /Using.*without explicitly enabling/,
+              {:replacement=>"the new `:expect` syntax or explicitly enable `:should`"}
+            ]
+
+            expect(RSpec).to receive(:deprecate).with(*expected_arguments)
+            3.should eq(3)
+          end
+
+          it "includes the call site in the deprecation warning by default" do
+            expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
+            3.should eq(3)
+          end
+
+          it "does not warn when only the should syntax is explicitly configured" do
+            configure_syntax(:should)
+            RSpec.should_not receive(:deprecate)
+            3.should eq(3)
+          end
+
+          it "does not warn when both the should and expect syntaxes are explicitly configured" do
+            configure_syntax([:should, :expect])
+            expect(RSpec).not_to receive(:deprecate)
+            3.should eq(3)
+          end
+        end
+
+        it 'can re-enable the :should syntax' do
+          configure_syntax :expect
+          configure_syntax [:should, :expect]
+          configured_syntax.should eq([:should, :expect])
+
+          3.should eq(3)
+          3.should_not eq(4)
+          expect(3).to eq(3)
+        end
+
+        it 'can re-enable the :expect syntax' do
+          configure_syntax :should
+          configure_syntax [:should, :expect]
+          configured_syntax.should eq([:should, :expect])
+
+          3.should eq(3)
+          3.should_not eq(4)
+          expect(3).to eq(3)
+        end
+      end
+
+      def configure_default_syntax
+        RSpec::Matchers.configuration.reset_syntaxes_to_default
+      end
+
+      describe "configuring rspec-expectations directly" do
+        it_behaves_like "configuring the expectation syntax" do
+          def configure_syntax(syntax)
+            RSpec::Matchers.configuration.syntax = syntax
+          end
+
+          def configured_syntax
+            RSpec::Matchers.configuration.syntax
+          end
+        end
+      end
+
+      describe "configuring using the rspec-core config API" do
+        it_behaves_like "configuring the expectation syntax" do
+          def configure_syntax(syntax)
+            RSpec.configure do |rspec|
+              rspec.expect_with :rspec do |c|
+                c.syntax = syntax
+              end
+            end
+          end
+
+
+          def configured_syntax
+            RSpec.configure do |rspec|
+              rspec.expect_with :rspec do |c|
+                return c.syntax
+              end
+            end
+          end
+        end
+      end
+
+      it 'enables both syntaxes by default' do
+        # This is kinda a hack, but since we want to enforce use of
+        # the expect syntax within our specs here, we have modified the
+        # config setting, which makes it hard to get at the original
+        # default value. in spec_helper.rb we store the default value
+        # in $default_expectation_syntax so we can use it here.
+        expect($default_expectation_syntax).to contain_exactly(:expect, :should)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+module RSpec
+  module Expectations
+    # so our examples below can set expectations about the target
+    ExpectationTarget.send(:attr_reader, :target)
+
+    RSpec.describe ExpectationTarget do
+      context 'when constructed via #expect' do
+        it 'constructs a new instance targetting the given argument' do
+          expect(expect(7).target).to eq(7)
+        end
+
+        it 'constructs a new instance targetting the given block' do
+          block = lambda {}
+          expect(expect(&block).target).to be(block)
+        end
+
+        it 'raises an ArgumentError when given an argument and a block' do
+          expect {
+            expect(7) { }
+          }.to raise_error(ArgumentError)
+        end
+
+        it 'raises a wrong number of args ArgumentError when given two args' do
+          expect {
+            expect(1, 2)
+          }.to raise_error(ArgumentError, /wrong number of arg/)
+        end
+
+        it 'raises an ArgumentError when given neither an argument nor a block' do
+          expect {
+            expect
+          }.to raise_error(ArgumentError)
+        end
+
+        it 'can be passed nil' do
+          expect(expect(nil).target).to be_nil
+        end
+
+        it 'passes a valid positive expectation' do
+          expect(5).to eq(5)
+        end
+
+        it 'passes a valid negative expectation' do
+          expect(5).not_to eq(4)
+        end
+
+        it 'passes a valid negative expectation with a split infinitive' do
+          expect(5).to_not eq(4)
+        end
+
+        it 'fails an invalid positive expectation' do
+          expect {
+            expect(5).to eq(4)
+          }.to fail_with(/expected: 4.*got: 5/m)
+        end
+
+        it 'fails an invalid negative expectation' do
+          message = /expected 5 not to be a kind of Fixnum/
+          expect {
+            expect(5).not_to be_a(Fixnum)
+          }.to fail_with(message)
+        end
+
+        it 'fails an invalid negative expectation with a split infinitive' do
+          message = /expected 5 not to be a kind of Fixnum/
+          expect {
+            expect(5).to_not be_a(Fixnum)
+          }.to fail_with(message)
+        end
+
+        it 'does not support operator matchers from #to' do
+          expect {
+            expect(3).to == 3
+          }.to raise_error(ArgumentError)
+        end
+
+        it 'does not support operator matchers from #not_to' do
+          expect {
+            expect(3).not_to == 4
+          }.to raise_error(ArgumentError)
+        end
+      end
+
+      context "when passed a block" do
+        it 'can be used with a block matcher' do
+          expect { }.not_to raise_error
+        end
+
+        context 'when passed a value matcher' do
+          not_a_block_matcher_error = /You must pass an argument rather than a block to use the provided matcher/
+
+          it 'raises an error that directs the user to pass an arg rather than a block' do
+            expect {
+              expect { }.to be_an(Object)
+            }.to fail_with(not_a_block_matcher_error)
+
+            expect {
+              expect { }.not_to be_nil
+            }.to fail_with(not_a_block_matcher_error)
+
+            expect {
+              expect { }.to_not be_nil
+            }.to fail_with(not_a_block_matcher_error)
+          end
+
+          it 'assumes a custom matcher that does not define `supports_block_expectations?` is not a block matcher (since it is relatively rare)' do
+            custom_matcher = Module.new do
+              def self.matches?(value); true; end
+              def self.description; "foo"; end
+            end
+
+            expect(3).to custom_matcher # to show the custom matcher can be used as a matcher
+
+            expect {
+              expect { 3 }.to custom_matcher
+            }.to fail_with(not_a_block_matcher_error)
+          end
+
+          it "uses the matcher's `description` in the error message" do
+            custom_matcher = Module.new do
+              def self.supports_block_expectations?; false; end
+              def self.description; "matcher-description"; end
+            end
+
+            expect {
+              expect { }.to custom_matcher
+            }.to fail_with(/\(matcher-description\)/)
+          end
+
+          context 'when the matcher does not define `description` (since it is an optional part of the protocol)' do
+            it 'uses `inspect` in the error message instead' do
+              custom_matcher = Module.new do
+                def self.supports_block_expectations?; false; end
+                def self.inspect; "matcher-inspect"; end
+              end
+
+              expect {
+                expect { }.to custom_matcher
+              }.to fail_with(/\(matcher-inspect\)/)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/rspec-expectations/spec/rspec/expectations/extensions/kernel_spec.rb

@@ -0,0 +1,69 @@
+RSpec.describe Object, "#should" do
+  before(:example) do
+    @target = "target"
+    @matcher = double("matcher")
+    allow(@matcher).to receive(:matches?).and_return(true)
+    allow(@matcher).to receive(:failure_message)
+  end
+
+  it "accepts and interacts with a matcher" do
+    expect(@matcher).to receive(:matches?).with(@target).and_return(true)
+    expect(@target).to @matcher
+  end
+
+  it "asks for a failure_message when matches? returns false" do
+    expect(@matcher).to receive(:matches?).with(@target).and_return(false)
+    expect(@matcher).to receive(:failure_message).and_return("the failure message")
+    expect {
+      expect(@target).to @matcher
+    }.to fail_with("the failure message")
+  end
+
+  context "on interpretters that have BasicObject", :if => defined?(BasicObject) do
+    let(:proxy_class) do
+      Class.new(BasicObject) do
+        def initialize(target)
+          @target = target
+        end
+
+        def proxied?
+          true
+        end
+
+        def respond_to?(method, *args)
+          method.to_sym == :proxied? || @target.respond_to?(symbol, *args)
+        end
+
+        def method_missing(name, *args)
+          @target.send(name, *args)
+        end
+      end
+    end
+
+    it 'works properly on BasicObject-subclassed proxy objects' do
+      expect(proxy_class.new(Object.new)).to be_proxied
+    end
+  end
+end
+
+RSpec.describe Object, "#should_not" do
+  before(:example) do
+    @target = "target"
+    @matcher = double("matcher")
+  end
+
+  it "accepts and interacts with a matcher" do
+    expect(@matcher).to receive(:matches?).with(@target).and_return(false)
+    allow(@matcher).to receive(:failure_message_when_negated)
+
+    expect(@target).not_to @matcher
+  end
+
+  it "asks for a failure_message_when_negated when matches? returns true" do
+    expect(@matcher).to receive(:matches?).with(@target).and_return(true)
+    expect(@matcher).to receive(:failure_message_when_negated).and_return("the failure message for should not")
+    expect {
+      expect(@target).not_to @matcher
+    }.to fail_with("the failure message for should not")
+  end
+end

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

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+RSpec.describe RSpec::Expectations, "#fail_with" do
+  let(:differ) { double("differ") }
+
+  before(:example) do
+    allow(RSpec::Matchers.configuration).to receive_messages(:color? => false)
+    allow(RSpec::Expectations).to receive(:differ) { differ }
+  end
+
+  it "includes a diff if expected and actual are diffable" do
+    expect(differ).to receive(:diff).and_return("diff text")
+
+    expect {
+      RSpec::Expectations.fail_with "message", "abc", "def"
+    }.to fail_with("message\nDiff:diff text")
+  end
+
+  it "does not include the diff if expected and actual are not diffable" do
+    expect(differ).to receive(:diff).and_return("")
+
+    expect {
+      RSpec::Expectations.fail_with "message", "abc", "def"
+    }.to fail_with("message")
+  end
+
+  it "raises an error if message is not present" do
+    expect(differ).not_to receive(:diff)
+
+    expect {
+      RSpec::Expectations.fail_with nil
+    }.to raise_error(ArgumentError, /Failure message is nil\./)
+  end
+end
+
+RSpec.describe RSpec::Expectations, "#fail_with with matchers" do
+  before do
+    allow(RSpec::Matchers.configuration).to receive_messages(:color? => false)
+  end
+
+  it "uses matcher descriptions in place of matchers in diffs" do
+    expected = [a_string_matching(/foo/), a_string_matching(/bar/)]
+    actual = ["poo", "car"]
+
+    expected_diff = dedent(<<-EOS)
+      |
+      |@@ -1,2 +1,2 @@
+      |-["poo", "car"]
+      |+[(a string matching /foo/), (a string matching /bar/)]
+      |
+    EOS
+
+    expect {
+      RSpec::Expectations.fail_with "message", actual, expected
+    }.to fail_with("message\nDiff:#{expected_diff}")
+  end
+end
+
+RSpec.describe RSpec::Expectations, "#fail_with with --color" do
+  before do
+    allow(RSpec::Matchers.configuration).to receive_messages(:color? => true)
+  end
+
+  it "tells the differ to use color" do
+    expected = "foo bar baz\n"
+    actual = "foo bang baz\n"
+    expected_diff = "\e[0m\n\e[0m\e[34m@@ -1,2 +1,2 @@\n\e[0m\e[31m-foo bang baz\n\e[0m\e[32m+foo bar baz\n\e[0m"
+
+    expect {
+      RSpec::Expectations.fail_with "message", actual, expected
+    }.to fail_with("message\nDiff:#{expected_diff}")
+  end
+end