opal-connect-rspec 0.5.0

data/rspec-expectations/spec/rspec/expectations/minitest_integration_spec.rb

@@ -0,0 +1,25 @@
+module RSpec
+  RSpec.describe Matchers do
+
+    let(:sample_matchers) do
+      [:be,
+       :be_instance_of,
+       :be_kind_of]
+    end
+
+    context "once required", :slow do
+      include MinitestIntegration
+
+      it "includes itself in Minitest::Test" do
+        with_minitest_loaded do
+          minitest_case = MiniTest::Test.allocate
+          sample_matchers.each do |sample_matcher|
+              expect(minitest_case).to respond_to(sample_matcher)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/rspec-expectations/spec/rspec/expectations/syntax_spec.rb

@@ -0,0 +1,93 @@
+module RSpec
+  module Expectations
+    RSpec.describe Syntax do
+      context "when passing a message to an expectation" do
+        let(:warner) { ::Kernel }
+
+        let(:string_like_object) do
+          Struct.new(:to_str, :to_s).new(*(["Ceci n'est pas une Chaine."]*2))
+        end
+
+        let(:insufficiently_string_like_object) do
+          Struct.new(:to_s).new("Ceci n'est pas une Chaine.")
+        end
+
+        let(:callable_object) do
+          Struct.new(:call).new("Ceci n'est pas une Chaine.")
+        end
+
+        describe "expect(...).to" do
+          it "prints a warning when the message object isn't a String" do
+            expect(warner).to receive(:warn).with(/ignoring.*message/)
+            expect(3).to eq(3), :not_a_string
+          end
+
+          it "doesn't print a warning when message is a String" do
+            expect(warner).not_to receive(:warn)
+            expect(3).to eq(3), "a string"
+          end
+
+          it "doesn't print a warning when message responds to to_str" do
+            expect(warner).not_to receive(:warn)
+            expect(3).to eq(3), string_like_object
+          end
+
+          it "prints a warning when the message object handles to_s but not to_str" do
+            expect(warner).to receive(:warn).with(/ignoring.*message/)
+            expect(3).to eq(3), insufficiently_string_like_object
+          end
+
+          it "doesn't print a warning when message responds to call" do
+            expect(warner).not_to receive(:warn)
+            expect(3).to eq(3), callable_object
+          end
+        end
+
+        describe "expect(...).not_to" do
+          it "prints a warning when the message object isn't a String" do
+            expect(warner).to receive(:warn).with(/ignoring.*message/)
+            expect(3).not_to eq(4), :not_a_string
+          end
+
+          it "doesn't print a warning when message is a String" do
+            expect(warner).not_to receive(:warn)
+            expect(3).not_to eq(4), "a string"
+          end
+
+          it "doesn't print a warning when message responds to to_str" do
+            expect(warner).not_to receive(:warn)
+            expect(3).not_to eq(4), string_like_object
+          end
+
+          it "prints a warning when the message object handles to_s but not to_str" do
+            expect(warner).to receive(:warn).with(/ignoring.*message/)
+            expect(3).not_to eq(4), insufficiently_string_like_object
+          end
+
+          it "doesn't print a warning when message responds to call" do
+            expect(warner).not_to receive(:warn)
+            expect(3).not_to eq(4), callable_object
+          end
+        end
+      end
+
+      describe "enabling the should syntax on something other than the default syntax host" do
+        include_context "with the default expectation syntax"
+
+        it "continues to warn about the should syntax" do
+          my_host = Class.new
+          expect(RSpec).to receive(:deprecate)
+          Syntax.enable_should(my_host)
+
+          3.should eq 3
+        end
+      end
+    end
+  end
+
+  RSpec.describe Expectations do
+    it "does not inadvertently define BasicObject on 1.8", :if => RUBY_VERSION.to_f < 1.9 do
+      expect(defined?(::BasicObject)).to be nil
+    end
+  end
+end

data/rspec-expectations/spec/rspec/expectations_spec.rb

@@ -0,0 +1,15 @@
+require 'rspec/support/spec/prevent_load_time_warnings'
+
+RSpec.describe "RSpec::Expectations" do
+  it_behaves_like 'a library that issues no warnings when loaded', 'rspec-expectations',
+    # We define minitest constants because rspec/expectations/minitest_integration
+    # expects these constants to already be defined.
+    'module Minitest; class Assertion; end; module Test; end; end',
+    'require "rspec/expectations"'
+
+  it 'does not allow expectation failures to be caught by a bare rescue' do
+    expect {
+      expect(2).to eq(3) rescue nil
+    }.to fail_matching("expected: 3")
+  end
+end

data/rspec-expectations/spec/rspec/matchers/aliased_matcher_spec.rb

@@ -0,0 +1,113 @@
+module RSpec
+  module Matchers
+    RSpec.describe AliasedMatcher do
+      RSpec::Matchers.define :my_base_matcher do
+        match { |actual| actual == foo }
+
+        def foo
+          13
+        end
+
+        def description
+          "my base matcher description"
+        end
+      end
+      RSpec::Matchers.alias_matcher :alias_of_my_base_matcher, :my_base_matcher
+
+      it_behaves_like "an RSpec matcher", :valid_value => 13, :invalid_value => nil do
+        let(:matcher) { alias_of_my_base_matcher }
+      end
+
+      shared_examples "making a copy" do |copy_method|
+        context "when making a copy via `#{copy_method}`" do
+          it "uses a copy of the base matcher" do
+            base_matcher = include(3)
+            aliased = AliasedMatcher.new(base_matcher, Proc.new {})
+            copy = aliased.__send__(copy_method)
+
+            expect(copy).not_to equal(aliased)
+            expect(copy.base_matcher).not_to equal(base_matcher)
+            expect(copy.base_matcher).to be_a(RSpec::Matchers::BuiltIn::Include)
+            expect(copy.base_matcher.expected).to eq([3])
+          end
+
+          it "copies custom matchers properly so they can work even though they have singleton behavior" do
+            base_matcher = my_base_matcher
+            aliased = AliasedMatcher.new(base_matcher, Proc.new { |a| a })
+            copy = aliased.__send__(copy_method)
+
+            expect(copy).not_to equal(aliased)
+            expect(copy.base_matcher).not_to equal(base_matcher)
+
+            expect(13).to copy
+
+            expect { expect(15).to copy }.to fail_with(/expected 15/)
+          end
+        end
+      end
+
+      include_examples "making a copy", :dup
+      include_examples "making a copy", :clone
+
+      it 'can get a method object for delegated methods', :if => (RUBY_VERSION.to_f > 1.8) do
+        matcher = my_base_matcher
+        decorated = AliasedMatcher.new(matcher, Proc.new { })
+
+        expect(decorated.method(:foo).call).to eq(13)
+      end
+
+      it 'can get a method object for `description`' do
+        matcher = my_base_matcher
+        decorated = AliasedMatcher.new(matcher, Proc.new { "overriden description" })
+
+        expect(decorated.method(:description).call).to eq("overriden description")
+      end
+
+      RSpec::Matchers.alias_matcher :my_overriden_matcher, :my_base_matcher do |desc|
+        desc + " (overriden)"
+      end
+
+      it 'overrides the description with the provided block' do
+        matcher = my_overriden_matcher
+        expect(matcher.description).to eq("my base matcher description (overriden)")
+      end
+
+      RSpec::Matchers.alias_matcher :my_blockless_override, :my_base_matcher
+
+      it 'provides a default description override based on the old and new games' do
+        matcher = my_blockless_override
+        expect(matcher.description).to eq("my blockless override description")
+      end
+
+      RSpec::Matchers.define_negated_matcher :avoid_outputting, :output
+
+      it 'works properly with a chained method off a negated matcher' do
+        expect { }.to avoid_outputting.to_stdout
+
+        expect {
+          expect { $stdout.puts "a" }.to avoid_outputting.to_stdout
+        }.to fail
+      end
+
+      context "when negating a matcher that does not define `description` (which is an optional part of the matcher protocol)" do
+        def matcher_without_description
+          matcher = Object.new
+          def matcher.matches?(v); v; end
+          def matcher.failure_message; "match failed"; end
+          def matcher.chained; self; end
+          expect(RSpec::Matchers.is_a_matcher?(matcher)).to be true
+
+          matcher
+        end
+
+        RSpec::Matchers.define_negated_matcher :negation_of_matcher_without_description, :matcher_without_description
+
+        it 'works properly' do
+          expect(true).to matcher_without_description.chained
+          expect(false).to negation_of_matcher_without_description.chained
+        end
+      end
+    end
+  end
+end
+

data/rspec-expectations/spec/rspec/matchers/aliases_spec.rb

@@ -0,0 +1,455 @@
+module RSpec
+  RSpec.describe Matchers, "aliases", :order => :defined do
+    matcher :be_aliased_to do |old_matcher|
+      chain :with_description do |desc|
+        @expected_desc = desc
+      end
+
+      match do |aliased_matcher|
+        @actual_desc = aliased_matcher.description
+
+        @actual_desc == @expected_desc &&
+        aliased_matcher.base_matcher.class == old_matcher.class
+      end
+
+      failure_message do |aliased_matcher|
+        "expected #{aliased_matcher} to be aliased to #{old_matcher} with " +
+        "description: #{@expected_desc.inspect}, but got #{@actual_desc.inspect}"
+      end
+
+      description do |aliased_matcher|
+        "have an alias for #{old_matcher.description.inspect} with description: #{@expected_desc.inspect}"
+      end
+    end
+
+    specify do
+      expect(a_truthy_value).to be_aliased_to(be_truthy).with_description("a truthy value")
+    end
+
+    specify do
+      expect(a_falsey_value).to be_aliased_to(be_falsey).with_description("a falsey value")
+    end
+
+    specify do
+      expect(be_falsy).to be_aliased_to(be_falsey).with_description("be falsy")
+    end
+
+    specify do
+      expect(a_falsy_value).to be_aliased_to(be_falsey).with_description("a falsy value")
+    end
+
+    specify do
+      expect(a_nil_value).to be_aliased_to(be_nil).with_description("a nil value")
+    end
+
+    specify do
+      expect(a_value > 3).to be_aliased_to(be > 3).with_description("a value > 3")
+    end
+
+    specify do
+      expect(a_value < 3).to be_aliased_to(be < 3).with_description("a value < 3")
+    end
+
+    specify do
+      expect(a_value <= 3).to be_aliased_to(be <= 3).with_description("a value <= 3")
+    end
+
+    specify do
+      expect(a_value == 3).to be_aliased_to(be == 3).with_description("a value == 3")
+    end
+
+    specify do
+      expect(a_value === 3).to be_aliased_to(be === 3).with_description("a value === 3")
+    end
+
+    specify do
+      expect(
+        an_instance_of(Integer)
+      ).to be_aliased_to(
+        be_an_instance_of(Integer)
+      ).with_description("an instance of Integer")
+    end
+
+    specify do
+      expect(
+        a_kind_of(Integer)
+      ).to be_aliased_to(
+        be_a_kind_of(Integer)
+      ).with_description("a kind of Integer")
+    end
+
+    specify do
+      expect(
+        a_value_between(1, 10)
+      ).to be_aliased_to(
+        be_between(1, 10)
+      ).with_description("a value between 1 and 10 (inclusive)")
+    end
+
+    specify do
+      expect(
+        a_value_within(0.1).of(3)
+      ).to be_aliased_to(
+        be_within(0.1).of(3)
+      ).with_description("a value within 0.1 of 3")
+    end
+
+    specify do
+      expect(
+        within(0.1).of(3)
+      ).to be_aliased_to(
+        be_within(0.1).of(3)
+      ).with_description("within 0.1 of 3")
+    end
+
+    specify do
+      expect(a_block_changing).to be_aliased_to(change).with_description("a block changing result")
+    end
+
+    specify do
+      expect(changing).to be_aliased_to(change).with_description("changing result")
+    end
+
+    specify do
+      expect(
+        a_collection_containing_exactly(1, 2)
+      ).to be_aliased_to(
+        contain_exactly(1, 2)
+      ).with_description("a collection containing exactly 1 and 2")
+    end
+
+    specify do
+      expect(
+        containing_exactly(1, 2)
+      ).to be_aliased_to(
+        contain_exactly(1, 2)
+      ).with_description("containing exactly 1 and 2")
+    end
+
+    specify do
+      expect(
+        a_range_covering(1, 2)
+      ).to be_aliased_to(
+        cover(1, 2)
+      ).with_description("a range covering 1 and 2")
+    end
+
+    specify do
+      expect(
+        covering(1, 2)
+      ).to be_aliased_to(
+        cover(1, 2)
+      ).with_description("covering 1 and 2")
+    end
+
+    specify do
+      expect(
+        ending_with(23)
+      ).to be_aliased_to(
+        end_with(23)
+      ).with_description("ending with 23")
+    end
+
+    specify do
+      expect(
+        a_collection_ending_with(23)
+      ).to be_aliased_to(
+        end_with(23)
+      ).with_description("a collection ending with 23")
+    end
+
+    specify do
+      expect(
+        a_string_ending_with("z")
+      ).to be_aliased_to(
+        end_with("z")
+      ).with_description('a string ending with "z"')
+    end
+
+    specify do
+      expect(
+        an_object_eq_to(3)
+      ).to be_aliased_to(eq 3).with_description("an object eq to 3")
+    end
+
+    specify do
+      expect(
+        eq_to(3)
+      ).to be_aliased_to(eq 3).with_description("eq to 3")
+    end
+
+    specify do
+      expect(
+        an_object_eql_to(3)
+      ).to be_aliased_to(eql 3).with_description("an object eql to 3")
+    end
+
+    specify do
+      expect(
+        eql_to(3)
+      ).to be_aliased_to(eql 3).with_description("eql to 3")
+    end
+
+    specify do
+      expect(
+        an_object_equal_to(3)
+      ).to be_aliased_to(equal 3).with_description("an object equal to 3")
+    end
+
+    specify do
+      expect(
+        equal_to(3)
+      ).to be_aliased_to(equal 3).with_description("equal to 3")
+    end
+
+    specify do
+      expect(
+        an_object_existing
+      ).to be_aliased_to(exist).with_description("an object existing")
+    end
+
+    specify do
+      expect(existing).to be_aliased_to(exist).with_description("existing")
+    end
+
+    specify do
+      expect(
+          an_object_having_attributes(:age => 32)
+      ).to be_aliased_to(
+          have_attributes(:age => 32)
+      ).with_description("an object having attributes {:age => 32}")
+    end
+
+    specify do
+      expect(
+        a_string_including("a")
+      ).to be_aliased_to(
+        include("a")
+      ).with_description('a string including "a"')
+    end
+
+    specify do
+      expect(
+        a_collection_including("a")
+      ).to be_aliased_to(
+        include("a")
+      ).with_description('a collection including "a"')
+    end
+
+    specify do
+      expect(
+        a_hash_including(:a => 5)
+      ).to be_aliased_to(
+        include(:a => 5)
+      ).with_description('a hash including {:a => 5}')
+    end
+
+    specify do
+      expect(
+        including(3)
+      ).to be_aliased_to(
+        include(3)
+      ).with_description('including 3')
+    end
+
+    specify do
+      expect(
+        a_string_matching(/foo/)
+      ).to be_aliased_to(
+        match(/foo/)
+      ).with_description('a string matching /foo/')
+    end
+
+    specify do
+      expect(
+        an_object_matching(/foo/)
+      ).to be_aliased_to(
+        match(/foo/)
+      ).with_description('an object matching /foo/')
+    end
+
+    specify do
+      expect(
+        match_regex(/foo/)
+      ).to be_aliased_to(
+        match(/foo/)
+      ).with_description('match regex /foo/')
+    end
+
+    specify do
+      expect(
+        matching(/foo/)
+      ).to be_aliased_to(
+        match(/foo/)
+      ).with_description('matching /foo/')
+    end
+
+    specify do
+      expect(
+        a_block_outputting('foo').to_stdout
+      ).to be_aliased_to(
+        output('foo').to_stdout
+      ).with_description('a block outputting "foo" to stdout')
+    end
+
+    specify do
+      expect(
+        a_block_outputting('foo').to_stderr
+      ).to be_aliased_to(
+        output('foo').to_stderr
+      ).with_description('a block outputting "foo" to stderr')
+    end
+
+    specify do
+      expect(
+        a_block_raising(ArgumentError)
+      ).to be_aliased_to(
+        raise_error(ArgumentError)
+      ).with_description('a block raising ArgumentError')
+    end
+
+    specify do
+      expect(
+        raising(ArgumentError)
+      ).to be_aliased_to(
+        raise_error(ArgumentError)
+      ).with_description("raising ArgumentError")
+    end
+
+    specify do
+      expect(
+        an_object_responding_to(:foo)
+      ).to be_aliased_to(
+        respond_to(:foo)
+      ).with_description("an object responding to #foo")
+    end
+
+    specify do
+      expect(
+        responding_to(:foo)
+      ).to be_aliased_to(
+        respond_to(:foo)
+      ).with_description("responding to #foo")
+    end
+
+    specify do
+      expect(
+        an_object_satisfying { }
+      ).to be_aliased_to(
+        satisfy { }
+      ).with_description("an object satisfying block")
+    end
+
+    specify do
+      expect(
+        satisfying { }
+      ).to be_aliased_to(
+        satisfy { }
+      ).with_description("satisfying block")
+    end
+
+    specify do
+      expect(
+        a_collection_starting_with(23)
+      ).to be_aliased_to(
+        start_with(23)
+      ).with_description("a collection starting with 23")
+    end
+
+    specify do
+      expect(
+        a_string_starting_with("z")
+      ).to be_aliased_to(
+        start_with("z")
+      ).with_description('a string starting with "z"')
+    end
+
+    specify do
+      expect(
+        starting_with("d")
+      ).to be_aliased_to(
+        start_with("d")
+      ).with_description('starting with "d"')
+    end
+
+    specify do
+      expect(
+        a_block_throwing(:foo)
+      ).to be_aliased_to(
+        throw_symbol(:foo)
+      ).with_description("a block throwing :foo")
+    end
+
+    specify do
+      expect(
+        throwing(:foo)
+      ).to be_aliased_to(
+        throw_symbol(:foo)
+      ).with_description("throwing :foo")
+    end
+
+    specify do
+      expect(
+        a_block_yielding_control
+      ).to be_aliased_to(
+        yield_control
+      ).with_description("a block yielding control")
+    end
+
+    specify do
+      expect(
+        yielding_control
+      ).to be_aliased_to(
+        yield_control
+      ).with_description("yielding control")
+    end
+
+    specify do
+      expect(
+        a_block_yielding_with_no_args
+      ).to be_aliased_to(
+        yield_with_no_args
+      ).with_description("a block yielding with no args")
+    end
+
+    specify do
+      expect(
+        yielding_with_no_args
+      ).to be_aliased_to(
+        yield_with_no_args
+      ).with_description("yielding with no args")
+    end
+
+    specify do
+      expect(
+        a_block_yielding_with_args
+      ).to be_aliased_to(
+        yield_with_args
+      ).with_description("a block yielding with args")
+    end
+
+    specify do
+      expect(
+        yielding_with_args
+      ).to be_aliased_to(
+        yield_with_args
+      ).with_description("yielding with args")
+    end
+
+    specify do
+      expect(
+        a_block_yielding_successive_args
+      ).to be_aliased_to(
+        yield_successive_args
+      ).with_description("a block yielding successive args()")
+    end
+
+    specify do
+      expect(
+        yielding_successive_args
+      ).to be_aliased_to(
+        yield_successive_args
+      ).with_description("yielding successive args()")
+    end
+  end
+end