Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
tree: 16a133fcdd
Fetching contributors…

Cannot retrieve contributors at this time

235 lines (193 sloc) 7.665 kb
require 'spec_helper'
require 'delegate'
module RSpec
module Matchers
describe "RSpec::Matchers.configuration" do
it 'returns a memoized configuration instance' do
RSpec::Matchers.configuration.should be_a(RSpec::Matchers::Configuration)
RSpec::Matchers.configuration.should be(RSpec::Matchers.configuration)
end
end
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
RSpec.configuration.stub(:backtrace_clean_patterns) { [/clean-me/] }
end
it "defaults to rspec-core's backtrace formatter when rspec-core is loaded" do
expect(config.backtrace_formatter).to be(RSpec::Core::BacktraceFormatter)
expect(formatted_backtrace).to eq(cleaned_backtrace)
end
it "defaults to a null formatter when rspec-core is not loaded" do
stub_const("RSpec::Core", nil) # so the formatter module is not loaded
expect(formatted_backtrace).to eq(original_backtrace)
end
it "can be set to another backtrace formatter" do
config.backtrace_formatter = stub(:format_backtrace => ['a'])
expect(formatted_backtrace).to eq(['a'])
end
end
context 'on an interpreter that does not provide BasicObject', :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
shared_examples_for "configuring the expectation syntax" do
# We want a sandboxed method that ensures that we wind up with
# both syntaxes properly enabled when the example ends.
#
# On platforms that fork, using a sub process is the easiest,
# most robust way to achieve that.
#
# On jRuby we just re-enable both syntaxes at the end of the example;
# however, this is a generally inferior approach because it depends on
# the code-under-test working properly; if it doesn't work properly,
# it could leave things in a "broken" state where tons of other examples fail.
if RUBY_PLATFORM == "java"
def sandboxed
yield
ensure
configure_syntax([:should, :expect])
end
else
include InSubProcess
alias sandboxed in_sub_process
end
it 'is configured to :should and :expect by default' do
configured_syntax.should eq([:should, :expect])
3.should eq(3)
3.should_not eq(4)
expect(3).to eq(3)
end
it 'can limit the syntax to :should' do
sandboxed 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
end
it 'is a no-op when configured to :should twice' do
sandboxed do
::Kernel.stub(:method_added).and_raise("no methods should be added here")
configure_syntax :should
configure_syntax :should
end
end
it 'can limit the syntax to :expect' do
sandboxed 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
end
it 'is a no-op when configured to :expect twice' do
sandboxed do
RSpec::Matchers.stub(:method_added).and_raise("no methods should be added here")
configure_syntax :expect
configure_syntax :expect
end
end
it 'can re-enable the :should syntax' do
sandboxed 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
end
it 'can re-enable the :expect syntax' do
sandboxed 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
it 'does not add the deprecated #should to ExpectationTarget when only :should is enabled' do
et = Expectations::ExpectationTarget
sandboxed do
configure_syntax :should
et.new(Proc.new {}).should be_an(et)
et.new(Proc.new {}).should_not be_a(Proc)
end
end
it 'does not add the deprecated #should to ExpectationTarget when only :expect is enabled' do
sandboxed do
configure_syntax :expect
expect(expect(3)).not_to respond_to(:should)
expect(expect(3)).not_to respond_to(:should_not)
end
end
context 'when both :expect and :should are enabled' do
before { RSpec.stub(:warn) }
it 'allows `expect {}.should` to be used' do
sandboxed do
configure_syntax [:should, :expect]
expect { raise "boom" }.should raise_error("boom")
expect { }.should_not raise_error
end
end
it 'prints a deprecation notice when `expect {}.should` is used' do
sandboxed do
configure_syntax [:should, :expect]
RSpec.should_receive(:warn).with(/please use `expect \{ \}.to.*instead/)
expect { raise "boom" }.should raise_error("boom")
RSpec.should_receive(:warn).with(/please use `expect \{ \}.to_not.*instead/)
expect { }.should_not raise_error
end
end
end
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
end
end
end
Jump to Line
Something went wrong with that request. Please try again.