opal-rspec 0.6.2 → 0.7.0.rc.1

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

@@ -1,100 +0,0 @@
-RSpec.describe "expect(...).to match(expected)" do
-  it_behaves_like "an RSpec matcher", :valid_value => 'ab', :invalid_value => 'bc' do
-    let(:matcher) { match(/a/) }
-  end
-
-  it "passes when target (String) matches expected (Regexp)" do
-    expect("string").to match(/tri/)
-  end
-
-  it "passes when target (String) matches expected (String)" do
-    expect("string").to match("tri")
-  end
-
-  it "fails when target (String) does not match expected (Regexp)" do
-    expect {
-      expect("string").to match(/rings/)
-    }.to fail
-  end
-
-  it "fails when target (String) does not match expected (String)" do
-    expect {
-      expect("string").to match("rings")
-    }.to fail
-  end
-
-  it "provides message, expected and actual on failure" do
-    matcher = match(/rings/)
-    matcher.matches?("string")
-    expect(matcher.failure_message).to eq "expected \"string\" to match /rings/"
-  end
-
-  it "provides a diff on failure" do
-    allow(RSpec::Matchers.configuration).to receive(:color?).and_return(false)
-
-    failure_message_that_includes_diff = %r%
-\s*Diff:
-\s*@@ -1,2 \+1,2 @@
-\s*-/bar/
-\s*\+"foo"%
-
-    expect { expect("foo").to match(/bar/) }.to fail_with(failure_message_that_includes_diff)
-  end
-
-  context "when passed a data structure with matchers" do
-    it 'passes when the matchers match' do
-      expect(["food", 1.1]).to match([ a_string_matching(/foo/), a_value_within(0.2).of(1) ])
-    end
-
-    it 'fails when the matchers do not match' do
-      expect {
-        expect(["fod", 1.1]).to match([ a_string_matching(/foo/), a_value_within(0.2).of(1) ])
-      }.to fail_with('expected ["fod", 1.1] to match [(a string matching /foo/), (a value within 0.2 of 1)]')
-    end
-
-    it 'provides a description' do
-      description = match([ a_string_matching(/foo/), a_value_within(0.2).of(1) ]).description
-      expect(description).to eq("match [(a string matching /foo/), (a value within 0.2 of 1)]")
-    end
-  end
-end
-
-RSpec.describe "expect(...).not_to match(expected)" do
-  it "passes when target (String) matches does not match (Regexp)" do
-    expect("string").not_to match(/rings/)
-  end
-
-  it "passes when target (String) matches does not match (String)" do
-    expect("string").not_to match("rings")
-  end
-
-  it "fails when target (String) matches expected (Regexp)" do
-    expect {
-      expect("string").not_to match(/tri/)
-    }.to fail
-  end
-
-  it "fails when target (String) matches expected (String)" do
-    expect {
-      expect("string").not_to match("tri")
-    }.to fail
-  end
-
-  it "provides message, expected and actual on failure" do
-    matcher = match(/tri/)
-    matcher.matches?("string")
-    expect(matcher.failure_message_when_negated).to eq "expected \"string\" not to match /tri/"
-  end
-
-  context "when passed a data structure with matchers" do
-    it 'passes when the matchers match' do
-      expect(["food", 1.1]).not_to match([ a_string_matching(/fod/), a_value_within(0.2).of(1) ])
-    end
-
-    it 'fails when the matchers do not match' do
-      expect {
-        expect(["fod", 1.1]).not_to match([ a_string_matching(/fod/), a_value_within(0.2).of(1) ])
-      }.to fail_with('expected ["fod", 1.1] not to match [(a string matching /fod/), (a value within 0.2 of 1)]')
-    end
-  end
-end

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

@@ -1,250 +0,0 @@
-class MethodOverrideObject
-  def method
-    :foo
-  end
-end
-
-class MethodMissingObject < Struct.new(:original)
-  undef ==
-
-  def method_missing(name, *args, &block)
-    original.__send__ name, *args, &block
-  end
-end
-
-RSpec.describe "operator matchers", :uses_should do
-  describe "should ==" do
-    it "delegates message to target" do
-      subject = "apple"
-      expect(subject).to receive(:==).with("apple").and_return(true)
-      subject.should == "apple"
-    end
-
-    it "returns true on success" do
-      subject = "apple"
-      (subject.should == "apple").should be_truthy
-    end
-
-    it "fails when target.==(actual) returns false" do
-      subject = "apple"
-      expect(RSpec::Expectations).to receive(:fail_with).with(%[expected: "orange"\n     got: "apple" (using ==)], "orange", "apple")
-      subject.should == "orange"
-    end
-
-    it "works when #method is overriden" do
-      myobj = MethodOverrideObject.new
-      expect {
-        myobj.should == myobj
-      }.to_not raise_error
-    end
-
-    it "works when implemented via method_missing" do
-      obj = Object.new
-
-      myobj = MethodMissingObject.new(obj)
-      (myobj.should == obj).nil? # just to avoid `useless use of == in void context` warning
-      myobj.should_not == Object.new
-    end
-  end
-
-  describe "unsupported operators", :if => RUBY_VERSION.to_f == 1.9 do
-    it "raises an appropriate error for should != expected" do
-      expect {
-        "apple".should != "pear"
-      }.to raise_error(/does not support `should != expected`.  Use `should_not == expected`/)
-    end
-
-    it "raises an appropriate error for should_not != expected" do
-      expect {
-        "apple".should_not != "pear"
-      }.to raise_error(/does not support `should_not != expected`.  Use `should == expected`/)
-    end
-
-    it "raises an appropriate error for should !~ expected" do
-      expect {
-        "apple".should !~ /regex/
-      }.to raise_error(/does not support `should !~ expected`.  Use `should_not =~ expected`/)
-    end
-
-    it "raises an appropriate error for should_not !~ expected" do
-      expect {
-        "apple".should_not !~ /regex/
-      }.to raise_error(/does not support `should_not !~ expected`.  Use `should =~ expected`/)
-    end
-  end
-
-  describe "should_not ==" do
-    it "delegates message to target" do
-      subject = "orange"
-      expect(subject).to receive(:==).with("apple").and_return(false)
-      subject.should_not == "apple"
-    end
-
-    it "returns true on success" do
-      subject = "apple"
-      (subject.should_not == "orange").should be_falsey
-    end
-
-    it "fails when target.==(actual) returns false" do
-      subject = "apple"
-      expect(RSpec::Expectations).to receive(:fail_with).with(%[expected not: == "apple"\n         got:    "apple"], "apple", "apple")
-      subject.should_not == "apple"
-    end
-  end
-
-  describe "should ===" do
-    it "delegates message to target" do
-      subject = "apple"
-      expect(subject).to receive(:===).with("apple").and_return(true)
-      subject.should === "apple"
-    end
-
-    it "fails when target.===(actual) returns false" do
-      subject = "apple"
-      expect(subject).to receive(:===).with("orange").and_return(false)
-      expect(RSpec::Expectations).to receive(:fail_with).with(%[expected: "orange"\n     got: "apple" (using ===)], "orange", "apple")
-      subject.should === "orange"
-    end
-  end
-
-  describe "should_not ===" do
-    it "delegates message to target" do
-      subject = "orange"
-      expect(subject).to receive(:===).with("apple").and_return(false)
-      subject.should_not === "apple"
-    end
-
-    it "fails when target.===(actual) returns false" do
-      subject = "apple"
-      expect(subject).to receive(:===).with("apple").and_return(true)
-      expect(RSpec::Expectations).to receive(:fail_with).with(%[expected not: === "apple"\n         got:     "apple"], "apple", "apple")
-      subject.should_not === "apple"
-    end
-  end
-
-  describe "should =~" do
-    it "delegates message to target" do
-      subject = "foo"
-      expect(subject).to receive(:=~).with(/oo/).and_return(true)
-      subject.should =~ /oo/
-    end
-
-    it "fails when target.=~(actual) returns false" do
-      subject = "fu"
-      expect(subject).to receive(:=~).with(/oo/).and_return(false)
-      expect(RSpec::Expectations).to receive(:fail_with).with(%[expected: /oo/\n     got: "fu" (using =~)], /oo/, "fu")
-      subject.should =~ /oo/
-    end
-  end
-
-  describe "should_not =~" do
-    it "delegates message to target" do
-      subject = "fu"
-      expect(subject).to receive(:=~).with(/oo/).and_return(false)
-      subject.should_not =~ /oo/
-    end
-
-    it "fails when target.=~(actual) returns false" do
-      subject = "foo"
-      expect(subject).to receive(:=~).with(/oo/).and_return(true)
-      expect(RSpec::Expectations).to receive(:fail_with).with(%[expected not: =~ /oo/\n         got:    "foo"], /oo/, "foo")
-      subject.should_not =~ /oo/
-    end
-  end
-
-  describe "should >" do
-    it "passes if > passes" do
-      4.should > 3
-    end
-
-    it "fails if > fails" do
-      expect(RSpec::Expectations).to receive(:fail_with).with(%[expected: > 5\n     got:   4], 5, 4)
-      4.should > 5
-    end
-  end
-
-  describe "should >=" do
-    it "passes if actual == expected" do
-      4.should >= 4
-    end
-
-    it "passes if actual > expected" do
-      4.should >= 3
-    end
-
-    it "fails if > fails" do
-      expect(RSpec::Expectations).to receive(:fail_with).with(%[expected: >= 5\n     got:    4], 5, 4)
-      4.should >= 5
-    end
-  end
-
-  describe "should <" do
-    it "passes if < passes" do
-      4.should < 5
-    end
-
-    it "fails if > fails" do
-      expect(RSpec::Expectations).to receive(:fail_with).with(%[expected: < 3\n     got:   4], 3, 4)
-      4.should < 3
-    end
-  end
-
-  describe "should <=" do
-    it "passes if actual == expected" do
-      4.should <= 4
-    end
-
-    it "passes if actual < expected" do
-      4.should <= 5
-    end
-
-    it "fails if > fails" do
-      expect(RSpec::Expectations).to receive(:fail_with).with(%[expected: <= 3\n     got:    4], 3, 4)
-      4.should <= 3
-    end
-  end
-
-  describe "OperatorMatcher registry" do
-    let(:custom_klass) { Class.new }
-    let(:custom_subklass) { Class.new(custom_klass) }
-
-    after {
-      RSpec::Matchers::BuiltIn::OperatorMatcher.unregister(custom_klass, "=~")
-    }
-
-    it "allows operator matchers to be registered for types" do
-      RSpec::Matchers::BuiltIn::OperatorMatcher.register(custom_klass, "=~", RSpec::Matchers::BuiltIn::Match)
-      expect(RSpec::Matchers::BuiltIn::OperatorMatcher.get(custom_klass, "=~")).to eq(RSpec::Matchers::BuiltIn::Match)
-    end
-
-    it "considers ancestors when finding an operator matcher" do
-      RSpec::Matchers::BuiltIn::OperatorMatcher.register(custom_klass, "=~", RSpec::Matchers::BuiltIn::Match)
-      expect(RSpec::Matchers::BuiltIn::OperatorMatcher.get(custom_subklass, "=~")).to eq(RSpec::Matchers::BuiltIn::Match)
-    end
-
-    it "returns nil if there is no matcher registered for a type" do
-      expect(RSpec::Matchers::BuiltIn::OperatorMatcher.get(custom_klass, "=~")).to be_nil
-    end
-  end
-
-  describe RSpec::Matchers::BuiltIn::PositiveOperatorMatcher do
-    it "works when the target has implemented #send" do
-      o = Object.new
-      def o.send(*args); raise "DOH! Library developers shouldn't use #send!" end
-      expect {
-        o.should == o
-      }.not_to raise_error
-    end
-  end
-
-  describe RSpec::Matchers::BuiltIn::NegativeOperatorMatcher do
-    it "works when the target has implemented #send" do
-      o = Object.new
-      def o.send(*args); raise "DOH! Library developers shouldn't use #send!" end
-      expect {
-        o.should_not == :foo
-      }.not_to raise_error
-    end
-  end
-end
-

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

@@ -1,168 +0,0 @@
-RSpec.shared_examples "output_to_stream" do |stream_name|
-  matcher_method = :"to_#{stream_name}"
-
-  define_method :matcher do |*args|
-    output(args.first).send(matcher_method)
-  end
-
-  it 'is diffable' do
-    expect(matcher).to be_diffable
-  end
-
-  it 'does not produce warnings when the failure message is accessed first' do
-    expect($VERBOSE).to be_truthy
-    expect { matcher.failure_message }.not_to output.to_stderr
-  end
-
-  context "expect { ... }.to output.#{matcher_method}" do
-    it "passes if the block outputs to #{stream_name}" do
-      expect { stream.print 'foo' }.to matcher
-    end
-
-    it "fails if the block does not output to #{stream_name}" do
-      expect {
-        expect { }.to matcher
-      }.to fail_with("expected block to output to #{stream_name}, but did not")
-    end
-  end
-
-  context "expect { ... }.not_to output.#{matcher_method}" do
-    it "passes if the block does not output to #{stream_name}" do
-      expect { }.not_to matcher
-    end
-
-    it "fails if the block outputs to #{stream_name}" do
-      expect {
-        expect { stream.print 'foo' }.not_to matcher
-      }.to fail_with("expected block to not output to #{stream_name}, but output \"foo\"")
-    end
-  end
-
-  context "expect { ... }.to output('string').#{matcher_method}" do
-    it "passes if the block outputs that string to #{stream_name}" do
-      expect { stream.print 'foo' }.to matcher("foo")
-    end
-
-    it "fails if the block does not output to #{stream_name}" do
-      expect {
-        expect { }.to matcher('foo')
-      }.to fail_with("expected block to output \"foo\" to #{stream_name}, but output nothing")
-    end
-
-    it "fails if the block outputs a different string to #{stream_name}" do
-      expect {
-        expect { stream.print 'food' }.to matcher('foo')
-      }.to fail_with("expected block to output \"foo\" to #{stream_name}, but output \"food\"")
-    end
-  end
-
-  context "expect { ... }.to_not output('string').#{matcher_method}" do
-    it "passes if the block outputs a different string to #{stream_name}" do
-      expect { stream.print 'food' }.to_not matcher('foo')
-    end
-
-    it "passes if the block does not output to #{stream_name}" do
-      expect { }.to_not matcher('foo')
-    end
-
-    it "fails if the block outputs the same string to #{stream_name}" do
-      expect {
-        expect { stream.print 'foo' }.to_not matcher('foo')
-      }.to fail_with("expected block to not output \"foo\" to #{stream_name}, but output \"foo\"")
-    end
-  end
-
-  context "expect { ... }.to output(/regex/).#{matcher_method}" do
-    it "passes if the block outputs a string to #{stream_name} that matches the regex" do
-      expect { stream.print 'foo' }.to matcher(/foo/)
-    end
-
-    it "fails if the block does not output to #{stream_name}" do
-      expect {
-        expect { }.to matcher(/foo/)
-      }.to fail_matching("expected block to output /foo/ to #{stream_name}, but output nothing\nDiff")
-    end
-
-    it "fails if the block outputs a string to #{stream_name} that does not match" do
-      expect {
-        expect { stream.print 'foo' }.to matcher(/food/)
-      }.to fail_matching("expected block to output /food/ to #{stream_name}, but output \"foo\"\nDiff")
-    end
-  end
-
-  context "expect { ... }.to_not output(/regex/).#{matcher_method}" do
-    it "passes if the block outputs a string to #{stream_name} that does not match the regex" do
-      expect { stream.print 'food' }.to_not matcher(/bar/)
-    end
-
-    it "passes if the block does not output to #{stream_name}" do
-      expect { }.to_not matcher(/foo/)
-    end
-
-    it "fails if the block outputs a string to #{stream_name} that matches the regex" do
-      expect {
-        expect { stream.print 'foo' }.to_not matcher(/foo/)
-      }.to fail_matching("expected block to not output /foo/ to #{stream_name}, but output \"foo\"\nDiff")
-    end
-  end
-
-  context "expect { ... }.to output(matcher).#{matcher_method}" do
-    it "passes if the block outputs a string to #{stream_name} that passes the given matcher" do
-      expect { stream.print 'foo' }.to matcher(a_string_starting_with("f"))
-    end
-
-    it "fails if the block outputs a string to #{stream_name} that does not pass the given matcher" do
-      expect {
-        expect { stream.print 'foo' }.to matcher(a_string_starting_with("b"))
-      }.to fail_matching("expected block to output a string starting with \"b\" to #{stream_name}, but output \"foo\"\nDiff")
-    end
-  end
-
-  context "expect { ... }.to_not output(matcher).#{matcher_method}" do
-    it "passes if the block does not output a string to #{stream_name} that passes the given matcher" do
-      expect { stream.print 'foo' }.to_not matcher(a_string_starting_with("b"))
-    end
-
-    it "fails if the block outputs a string to #{stream_name} that passes the given matcher" do
-      expect {
-        expect { stream.print 'foo' }.to_not matcher(a_string_starting_with("f"))
-      }.to fail_matching("expected block to not output a string starting with \"f\" to #{stream_name}, but output \"foo\"\nDiff")
-    end
-  end
-end
-
-module RSpec
-  module Matchers
-    RSpec.describe "output.to_stderr matcher" do
-      it_behaves_like("an RSpec matcher", :valid_value => lambda { warn('foo') }, :invalid_value => lambda {}) do
-        let(:matcher) { output.to_stderr }
-      end
-
-      include_examples "output_to_stream", :stderr do
-        let(:stream) { $stderr }
-      end
-    end
-
-    RSpec.describe "output.to_stdout matcher" do
-      it_behaves_like("an RSpec matcher", :valid_value => lambda { print 'foo' }, :invalid_value => lambda {}) do
-        let(:matcher) { output.to_stdout }
-      end
-
-      include_examples "output_to_stream", :stdout do
-        let(:stream) { $stdout }
-      end
-    end
-
-    RSpec.describe "output (without `to_stdout` or `to_stderr`)" do
-      it 'raises an error explaining the use is invalid' do
-        expect {
-          expect { stream.print 'foo' }.to output
-        }.to raise_error(/must chain.*to_stdout.*to_stderr/)
-      end
-
-      it 'still provides a description (e.g. when used in a one-liner)' do
-        expect(output("foo").description).to eq('output "foo" to some stream')
-      end
-    end
-  end
-end