opal-rspec 0.6.2 → 0.7.0.rc.1

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

@@ -1,67 +0,0 @@
-if (1..2).respond_to?(:cover?)
-  RSpec.describe "expect(...).to cover(expected)" do
-    it_behaves_like "an RSpec matcher", :valid_value => (1..10), :invalid_value => (20..30) do
-      let(:matcher) { cover(5) }
-    end
-
-    context "for a range target" do
-      it "passes if target covers expected" do
-        expect((1..10)).to cover(5)
-      end
-
-      it "fails if target does not cover expected" do
-        expect {
-          expect((1..10)).to cover(11)
-        }.to fail_with("expected 1..10 to cover 11")
-      end
-    end
-  end
-
-  RSpec.describe "expect(...).to cover(with, multiple, args)" do
-    context "for a range target" do
-      it "passes if target covers all items" do
-        expect((1..10)).to cover(4, 6)
-      end
-
-      it "fails if target does not cover any one of the items" do
-        expect {
-          expect((1..10)).to cover(4, 6, 11)
-        }.to fail_with("expected 1..10 to cover 4, 6, and 11")
-      end
-    end
-  end
-
-  RSpec.describe "expect(...).not_to cover(expected)" do
-    context "for a range target" do
-      it "passes if target does not cover expected" do
-        expect((1..10)).not_to cover(11)
-      end
-
-      it "fails if target covers expected" do
-        expect {
-          expect((1..10)).not_to cover(5)
-        }.to fail_with("expected 1..10 not to cover 5")
-      end
-    end
-  end
-
-  RSpec.describe "expect(...).not_to cover(with, multiple, args)" do
-    context "for a range target" do
-      it "passes if the target does not cover any of the expected" do
-        expect((1..10)).not_to cover(11, 12, 13)
-      end
-
-      it "fails if the target covers all of the expected" do
-        expect {
-          expect((1..10)).not_to cover(4, 6)
-        }.to fail_with("expected 1..10 not to cover 4 and 6")
-      end
-
-      it "fails if the target covers some (but not all) of the expected" do
-        expect {
-          expect((1..10)).not_to cover(5, 11)
-        }.to fail_with("expected 1..10 not to cover 5 and 11")
-      end
-    end
-  end
-end

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

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

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

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

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