opal-rspec 0.4.3 → 0.5.0.beta1

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

@@ -0,0 +1,176 @@
+require 'date'
+# complex is available w/o requiring on ruby 1.9+.
+# Loading it on 1.9+ issues a warning, so we only load it on 1.8.7.
+require 'complex' if RUBY_VERSION == '1.8.7'
+require 'bigdecimal'
+
+module RSpec
+  module Matchers
+    RSpec.describe "eq" do
+      it_behaves_like "an RSpec matcher", :valid_value => 1, :invalid_value => 2 do
+        let(:matcher) { eq(1) }
+      end
+
+      it "is diffable" do
+        expect(eq(1)).to be_diffable
+      end
+
+      it "matches when actual == expected" do
+        expect(1).to eq(1)
+      end
+
+      it "does not match when actual != expected" do
+        expect(1).not_to eq(2)
+      end
+
+      it "compares by sending == to actual (not expected)" do
+        called = false
+        actual = Class.new do
+          define_method :== do |other|
+            called = true
+          end
+        end.new
+
+        expect(actual).to eq :anything # to trigger the matches? method
+        expect(called).to be_truthy
+      end
+
+      it "describes itself" do
+        matcher = eq(1)
+        matcher.matches?(1)
+        expect(matcher.description).to eq "eq 1"
+      end
+
+      it "provides message, expected and actual on #failure_message" do
+        matcher = eq("1")
+        matcher.matches?(1)
+        expect(matcher.failure_message).to eq "\nexpected: \"1\"\n     got: 1\n\n(compared using ==)\n"
+      end
+
+      it "provides message, expected and actual on #negative_failure_message" do
+        matcher = eq(1)
+        matcher.matches?(1)
+        expect(matcher.failure_message_when_negated).to eq "\nexpected: value != 1\n     got: 1\n\n(compared using ==)\n"
+      end
+
+      it 'fails properly when the actual is an array of multiline strings' do
+        expect {
+          expect(["a\nb", "c\nd"]).to eq([])
+        }.to fail_matching("expected: []")
+      end
+
+      describe '#description' do
+        [
+            [nil, 'eq nil'],
+            [true, 'eq true'],
+            [false, 'eq false'],
+            [:symbol, 'eq :symbol'],
+            [1, 'eq 1'],
+            [1.2, 'eq 1.2'],
+            [Complex(1, 2), "eq #{Complex(1, 2).inspect}"],
+            ['foo', 'eq "foo"'],
+            [/regex/, 'eq /regex/'],
+            [['foo'], 'eq ["foo"]'],
+            [{:foo => :bar}, 'eq {:foo=>:bar}'],
+            [Class, 'eq Class'],
+            [RSpec, 'eq RSpec'],
+            [Date.new(2014, 1, 1), "eq #{Date.new(2014, 1, 1).inspect}"],
+            [Time.utc(2014, 1, 1), "eq #{Time.utc(2014, 1, 1).inspect}"],
+        ].each do |expected, expected_description|
+          context "with #{expected.inspect}" do
+            it "is \"#{expected_description}\"" do
+              expect(eq(expected).description).to eq expected_description
+            end
+          end
+        end
+
+        context 'with object' do
+          it 'matches with "^eq #<Object:0x[0-9a-f]*>$"' do
+            expect(eq(Object.new).description).to match(/^eq #<Object:0x[0-9a-f]*>$/)
+          end
+        end
+      end
+
+      context "Time Equality" do
+        RSpec::Matchers.define :a_string_with_differing_output do
+          match do |string|
+            time_strings = /expected: (.+)\n.*got: (.+)$/.match(string).captures
+            time_strings.uniq.count == 2
+          end
+        end
+
+        RSpec::Matchers.define :a_string_with_identical_output do
+          match do |string|
+            time_strings = /expected: value != (.+)\n.*got: (.+)$/.match(string).captures
+            time_strings.uniq.count == 1
+          end
+        end
+
+        context 'with Time objects' do
+          let(:time1) { Time.utc(1969, 12, 31, 19, 01, 40, 101) }
+          let(:time2) { Time.utc(1969, 12, 31, 19, 01, 40, 102) }
+
+          it 'produces different output for Times differing by milliseconds' do
+            expect {
+              expect(time1).to eq(time2)
+            }.to fail_with(a_string_with_differing_output)
+          end
+        end
+
+        context 'with DateTime objects' do
+          let(:date1) { DateTime.new(2000, 1, 1, 1, 1, Rational(1, 10)) }
+          let(:date2) { DateTime.new(2000, 1, 1, 1, 1, Rational(2, 10)) }
+
+          it 'produces different output for DateTimes differing by milliseconds' do
+            expect {
+              expect(date1).to eq(date2)
+            }.to fail_with(a_string_with_differing_output)
+          end
+
+          it 'does not not assume DateTime is defined since you need to require `date` to make it available' do
+            hide_const('DateTime')
+            expect {
+              expect(5).to eq(4)
+            }.to raise_error(RSpec::Expectations::ExpectationNotMetError)
+          end
+
+          it 'fails with identical output when the DateTimes are exactly the same' do
+            expect {
+              expect(date1).to_not eq(date1)
+            }.to fail_with(a_string_with_identical_output)
+          end
+
+          context 'when ActiveSupport is loaded' do
+            it "uses a custom format to ensure the output is different when DateTimes differ" do
+              stub_const("ActiveSupport", Module.new)
+              allow(date1).to receive(:inspect).and_return("Timestamp")
+              allow(date2).to receive(:inspect).and_return("Timestamp")
+
+              expect {
+                expect(date1).to eq(date2)
+              }.to fail_with(a_string_with_differing_output)
+            end
+          end
+        end
+      end
+
+      context 'with BigDecimal objects' do
+        let(:float)   { 1.1 }
+        let(:decimal) { BigDecimal("3.3") }
+
+        it 'fails with a conventional representation of the decimal' do
+          expect {
+            expect(float).to eq(decimal)
+          }.to fail_matching "expected: 3.3 (#<BigDecimal"
+        end
+
+        it 'does not not assume BigDecimal is defined since you need to require `bigdecimal` to make it available' do
+          hide_const('BigDecimal')
+          expect {
+            expect(5).to eq(4)
+          }.to raise_error(RSpec::Expectations::ExpectationNotMetError)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module RSpec
+  module Matchers
+    RSpec.describe "eql" do
+      it_behaves_like "an RSpec matcher", :valid_value => 1, :invalid_value => 2 do
+        let(:matcher) { eql(1) }
+      end
+
+      it "is diffable" do
+        expect(eql(1)).to be_diffable
+      end
+
+      it "matches when actual.eql?(expected)" do
+        expect(1).to eql(1)
+      end
+
+      it "does not match when !actual.eql?(expected)" do
+        expect(1).not_to eql(2)
+      end
+
+      it "describes itself" do
+        matcher = eql(1)
+        matcher.matches?(1)
+        expect(matcher.description).to eq "eql 1"
+      end
+
+      it "provides message, expected and actual on #failure_message" do
+        matcher = eql("1")
+        matcher.matches?(1)
+        expect(matcher.failure_message).to eq "\nexpected: \"1\"\n     got: 1\n\n(compared using eql?)\n"
+      end
+
+      it "provides message, expected and actual on #negative_failure_message" do
+        matcher = eql(1)
+        matcher.matches?(1)
+        expect(matcher.failure_message_when_negated).to eq "\nexpected: value != 1\n     got: 1\n\n(compared using eql?)\n"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+module RSpec
+  module Matchers
+    RSpec.describe "equal" do
+      it_behaves_like "an RSpec matcher", :valid_value => :a, :invalid_value => :b do
+        let(:matcher) { equal(:a) }
+      end
+
+      def inspect_object(o)
+        "#<#{o.class}:#{o.object_id}> => #{o.inspect}"
+      end
+
+      it "matches when actual.equal?(expected)" do
+        expect(1).to equal(1)
+      end
+
+      it "does not match when !actual.equal?(expected)" do
+        expect("1").not_to equal("1")
+      end
+
+      it "describes itself" do
+        matcher = equal(1)
+        matcher.matches?(1)
+        expect(matcher.description).to eq "equal 1"
+      end
+
+      context "when the expected object is falsey in conditinal semantics" do
+        it "describes itself with the expected object" do
+          matcher = equal(nil)
+          matcher.matches?(nil)
+          expect(matcher.description).to eq "equal nil"
+        end
+      end
+
+      context "when the expected object's #equal? always returns true" do
+        let(:strange_string) do
+          string = "foo"
+
+          def string.equal?(other)
+            true
+          end
+
+          string
+        end
+
+        it "describes itself with the expected object" do
+          matcher = equal(strange_string)
+          matcher.matches?(strange_string)
+          expect(matcher.description).to eq 'equal "foo"'
+        end
+      end
+
+      context "the output for expected" do
+        it "doesn't include extra object detail for `true`" do
+          expected, actual = true, "1"
+          expect {
+            expect(actual).to equal(expected)
+          }.to fail_with "\nexpected true\n     got #{inspect_object(actual)}\n"
+        end
+
+        it "doesn't include extra object detail for `false`" do
+          expected, actual = false, "1"
+          expect {
+            expect(actual).to equal(expected)
+          }.to fail_with "\nexpected false\n     got #{inspect_object(actual)}\n"
+        end
+
+        it "doesn't include extra object detail for `nil`" do
+          expected, actual = nil, "1"
+          expect {
+            expect(actual).to equal(expected)
+          }.to fail_with "\nexpected nil\n     got #{inspect_object(actual)}\n"
+        end
+      end
+
+      context "the output for actual" do
+        it "doesn't include extra object detail for `true`" do
+          expected, actual = true, false
+          expect {
+            expect(actual).to equal(expected)
+          }.to fail_with "\nexpected true\n     got false\n"
+        end
+
+        it "doesn't include extra object detail for `false`" do
+          expected, actual = false, nil
+          expect {
+            expect(actual).to equal(expected)
+          }.to fail_with "\nexpected false\n     got nil\n"
+        end
+
+        it "doesn't include extra object detail for `nil`" do
+          expected, actual = nil, false
+          expect {
+            expect(actual).to equal(expected)
+          }.to fail_with "\nexpected nil\n     got false\n"
+        end
+      end
+
+      it "suggests the `eq` matcher on failure" do
+        expected, actual = "1", "1"
+        expect {
+          expect(actual).to equal(expected)
+        }.to fail_with <<-MESSAGE
+
+expected #{inspect_object(expected)}
+     got #{inspect_object(actual)}
+
+Compared using equal?, which compares object identity,
+but expected and actual are not the same object. Use
+`expect(actual).to eq(expected)` if you don't care about
+object identity in this example.
+
+MESSAGE
+      end
+
+      it "provides message on #negative_failure_message" do
+        expected = actual = "1"
+        matcher = equal(expected)
+        matcher.matches?(actual)
+        expect(matcher.failure_message_when_negated).to eq <<-MESSAGE
+
+expected not #{inspect_object(expected)}
+         got #{inspect_object(actual)}
+
+Compared using equal?, which compares object identity.
+
+MESSAGE
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+require 'ostruct'
+
+RSpec.describe "exist matcher" do
+  it_behaves_like "an RSpec matcher", :valid_value => OpenStruct.new(:exist? => true),
+                                      :invalid_value => OpenStruct.new(:exist? => false) do
+    let(:matcher) { exist }
+  end
+
+  context "when the object does not respond to #exist? or #exists?" do
+    subject { double }
+
+    [:to, :not_to].each do |expect_method|
+      describe "expect(...).#{expect_method} exist" do
+        it "fails" do
+          expect {
+            expect(subject).send(expect_method, exist)
+          }.to fail_matching("it does not respond to either `exist?` or `exists?`")
+        end
+      end
+    end
+  end
+
+  it 'composes gracefully' do
+    expect([
+      double,
+      double(:exists? => false),
+      double(:exists? => true),
+    ]).to include existing
+  end
+
+  [:exist?, :exists?].each do |predicate|
+    context "when the object responds to ##{predicate}" do
+      describe "expect(...).to exist" do
+        it "passes if #{predicate}" do
+          expect(double(predicate => true)).to exist
+        end
+
+        it "fails if not #{predicate}" do
+          expect {
+            expect(double(predicate => false)).to exist
+          }.to fail_with(/expected .* to exist/)
+        end
+
+        it 'works when the object overrides `send`' do
+          klass = Struct.new(:message) do
+            def send
+              :message_sent
+            end
+
+            define_method predicate do
+              true
+            end
+          end
+
+          expect(klass.new("msg")).to exist
+        end
+      end
+
+      describe "expect(...).not_to exist" do
+        it "passes if not #{predicate}" do
+          expect(double(predicate => false)).not_to exist
+        end
+
+        it "fails if #{predicate}" do
+          expect {
+            expect(double(predicate => true)).not_to exist
+          }.to fail_with(/expected .* not to exist/)
+        end
+      end
+    end
+  end
+
+  context "when the object responds to #exist? and #exists?" do
+    context "when they both return falsey values" do
+      subject { double(:exist? => false, :exists? => nil) }
+
+      describe "expect(...).not_to exist" do
+        it "passes" do
+          expect(subject).not_to exist
+        end
+      end
+
+      describe "expect(...).to exist" do
+        it "fails" do
+          expect {
+            expect(subject).to exist
+          }.to fail_with(/expected .* to exist/)
+        end
+      end
+    end
+
+    context "when they both return truthy values" do
+      subject { double(:exist? => true, :exists? => "something true") }
+
+      describe "expect(...).not_to exist" do
+        it "fails" do
+          expect {
+            expect(subject).not_to exist
+          }.to fail_with(/expected .* not to exist/)
+        end
+      end
+
+      describe "expect(...).to exist" do
+        it "passes" do
+          expect(subject).to exist
+        end
+      end
+    end
+
+    context "when they return values with different truthiness" do
+      subject { double(:exist? => true, :exists? => false) }
+
+      [:to, :not_to].each do |expect_method|
+        describe "expect(...).#{expect_method} exist" do
+          it "fails" do
+            expect {
+              expect(subject).send(expect_method, exist)
+            }.to fail_matching("`exist?` and `exists?` returned different values")
+          end
+        end
+      end
+    end
+  end
+
+  it 'passes any provided arguments to the call to #exist?' do
+    object = double
+    expect(object).to receive(:exist?).with(:foo, :bar) { true }.at_least(:once)
+
+    expect(object).to exist(:foo, :bar)
+  end
+
+  it 'memoizes the call to `exist?` because it can be expensive (such as doing a DB query)' do
+    object = double
+    allow(object).to receive(:exist?) { false }
+    expect { expect(object).to exist }.to fail
+
+    expect(object).to have_received(:exist?).once
+  end
+end

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

@@ -0,0 +1,179 @@
+RSpec.describe "expect(...).to have_sym(*args)" do
+  it_behaves_like "an RSpec matcher", :valid_value => { :a => 1 },
+                                      :invalid_value => {} do
+    let(:matcher) { have_key(:a) }
+  end
+
+  it "passes if #has_sym?(*args) returns true" do
+    expect({:a => "A"}).to have_key(:a)
+  end
+
+  it "fails if #has_sym?(*args) returns false" do
+    expect {
+      expect({:b => "B"}).to have_key(:a)
+    }.to fail_with("expected #has_key?(:a) to return true, got false")
+  end
+
+  obj_with_block_method = Object.new
+  def obj_with_block_method.has_some_stuff?; yield; end
+
+  it 'forwards the given `{ }` block on to the `has_xyz?` method' do
+    expect(obj_with_block_method).to have_some_stuff { true }
+    expect(obj_with_block_method).to_not have_some_stuff { false }
+  end
+
+  it 'forwards the given `do..end` block on to the `has_xyz?` method' do
+    expect(obj_with_block_method).to have_some_stuff do
+      true
+    end
+
+    expect(obj_with_block_method).to_not have_some_stuff do
+      false
+    end
+  end
+
+  it 'favors a curly brace block over a do...end one since it binds to the matcher method' do
+    expect(obj_with_block_method).to have_some_stuff { true } do
+      false
+    end
+
+    expect(obj_with_block_method).not_to have_some_stuff { false } do
+      true
+    end
+  end
+
+  it 'does not include any args in the failure message if no args were given to the matcher' do
+    o = Object.new
+    def o.has_some_stuff?; false; end
+    expect {
+      expect(o).to have_some_stuff
+    }.to fail_with("expected #has_some_stuff? to return true, got false")
+  end
+
+  it 'includes multiple args in the failure message if multiple args were given to the matcher' do
+    o = Object.new
+    def o.has_some_stuff?(*_); false; end
+    expect {
+      expect(o).to have_some_stuff(:a, 7, "foo")
+    }.to fail_with('expected #has_some_stuff?(:a, 7, "foo") to return true, got false')
+  end
+
+  it "fails if #has_sym?(*args) returns nil" do
+    klass = Class.new do
+      def has_foo?
+      end
+    end
+    expect {
+      expect(klass.new).to have_foo
+    }.to fail_with(/expected #has_foo.* to return true, got false/)
+  end
+
+  it 'fails if #has_sym?(*args) is private' do
+    klass = Class.new do
+      private
+      def has_foo?
+        true
+      end
+    end
+    expect { expect(klass.new).to have_foo }.to fail_with(/private/)
+  end
+
+  it "fails if target does not respond to #has_sym?" do
+    expect {
+      expect(Object.new).to have_key(:a)
+    }.to fail_matching('to respond to `has_key?`')
+  end
+
+  it "reraises an exception thrown in #has_sym?(*args)" do
+    o = Object.new
+    def o.has_sym?(*args)
+      raise "Funky exception"
+    end
+    expect {
+      expect(o).to have_sym(:foo)
+    }.to raise_error("Funky exception")
+  end
+
+  it 'allows composable aliases to be defined' do
+    RSpec::Matchers.alias_matcher :an_object_having_sym, :have_sym
+    o = Object.new
+    def o.has_sym?(sym); sym == :foo; end
+
+    expect(o).to an_object_having_sym(:foo)
+    expect(o).not_to an_object_having_sym(:bar)
+
+    expect(an_object_having_sym(:foo).description).to eq("an object having sym :foo")
+  end
+
+  it 'composes gracefully' do
+    RSpec::Matchers.alias_matcher :an_object_having_foo, :have_foo
+
+    expect([
+      double,
+      double(:has_foo? => false),
+      double(:has_foo? => true),
+    ]).to include an_object_having_foo
+  end
+end
+
+RSpec.describe "expect(...).not_to have_sym(*args)" do
+  it "passes if #has_sym?(*args) returns false" do
+    expect({:a => "A"}).not_to have_key(:b)
+  end
+
+  it "passes if #has_sym?(*args) returns nil" do
+    klass = Class.new do
+      def has_foo?
+      end
+    end
+    expect(klass.new).not_to have_foo
+  end
+
+  it "fails if #has_sym?(*args) returns true" do
+    expect {
+      expect({:a => "A"}).not_to have_key(:a)
+    }.to fail_with("expected #has_key?(:a) to return false, got true")
+  end
+
+  it "fails if target does not respond to #has_sym?" do
+    expect {
+      expect(Object.new).not_to have_key(:a)
+    }.to fail_matching('to respond to `has_key?`')
+  end
+
+  it "reraises an exception thrown in #has_sym?(*args)" do
+    o = Object.new
+    def o.has_sym?(*args)
+      raise "Funky exception"
+    end
+    expect {
+      expect(o).not_to have_sym(:foo)
+    }.to raise_error("Funky exception")
+  end
+
+  it 'does not include any args in the failure message if no args were given to the matcher' do
+    o = Object.new
+    def o.has_some_stuff?; true; end
+    expect {
+      expect(o).not_to have_some_stuff
+    }.to fail_with("expected #has_some_stuff? to return false, got true")
+  end
+
+  it 'includes multiple args in the failure message if multiple args were given to the matcher' do
+    o = Object.new
+    def o.has_some_stuff?(*_); true; end
+    expect {
+      expect(o).not_to have_some_stuff(:a, 7, "foo")
+    }.to fail_with('expected #has_some_stuff?(:a, 7, "foo") to return false, got true')
+  end
+end
+
+RSpec.describe "has" do
+  it "works when the target implements #send" do
+    o = {:a => "A"}
+    def o.send(*args); raise "DOH! Library developers shouldn't use #send!" end
+    expect {
+      expect(o).to have_key(:a)
+    }.not_to raise_error
+  end
+end