opal-rspec 0.4.3 → 0.5.0.beta1

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

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

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