opal-connect-rspec 0.5.0

data/rspec-support/spec/rspec/support/directory_maker_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+require "fileutils"
+
+RSpec::Support.require_rspec_support("directory_maker")
+
+module RSpec::Support
+  describe DirectoryMaker do
+    shared_examples_for "an mkdir_p implementation" do
+      include_context "isolated directory"
+
+      let(:dirname) { File.join(%w[tmp a recursive structure]) }
+
+      def directory_exists?(dirname)
+        File.exist?(dirname) && File.directory?(dirname)
+      end
+
+      it "makes directories recursively" do
+        mkdir_p.call(dirname)
+        expect(directory_exists?(dirname)).to be true
+      end
+
+      it "does not raise if the directory already exists" do
+        Dir.mkdir("tmp")
+        mkdir_p.call(dirname)
+        expect(directory_exists?(dirname)).to be true
+      end
+
+      context "when a file already exists" do
+        before { File.open("tmp", "w") }
+
+        it "raises, as it can't make the directory" do
+          expect {
+            mkdir_p.call(dirname)
+          }.to raise_error(Errno::EEXIST)
+        end
+      end
+
+      context "when the path specified is absolute" do
+        let(:dirname) { "bees/ponies" }
+
+        it "makes directories recursively" do
+          mkdir_p.call(File.expand_path(dirname))
+          expect(directory_exists?(dirname)).to be true
+        end
+      end
+    end
+
+    describe ".mkdir_p" do
+      subject(:mkdir_p) { DirectoryMaker.method(:mkdir_p) }
+      it_behaves_like "an mkdir_p implementation"
+    end
+
+    describe "FileUtils.mkdir_p" do
+      subject(:mkdir_p) { FileUtils.method(:mkdir_p) }
+      it_behaves_like "an mkdir_p implementation"
+    end
+  end
+end

data/rspec-support/spec/rspec/support/encoded_string_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+require 'rspec/support/encoded_string'
+
+module RSpec::Support
+  describe EncodedString do
+    let(:target_encoding) { 'UTF-8' }
+
+    delegated_methods = String.instance_methods.map(&:to_s) & %w[eql? lines == encoding empty?]
+    delegated_methods.each do |delegated_method|
+      it "responds to #{delegated_method}" do
+        encoded_string = EncodedString.new("abc", target_encoding)
+        expect(encoded_string).to respond_to(delegated_method)
+      end
+    end
+
+    if String.method_defined?(:encoding)
+      describe '#source_encoding' do
+        it 'knows the original encoding of the string' do
+          str = EncodedString.new("abc".encode('ASCII-8BIT'), "UTF-8")
+          expect( str.source_encoding.to_s ).to eq('ASCII-8BIT')
+        end
+      end
+
+      let(:ascii_arrow_symbol) { "\xAE" }
+
+      let(:utf_8_euro_symbol) { "\xE2\x82\xAC" }
+
+      describe '#<<' do
+        context 'with strings that can be converted to the target encoding' do
+          it 'encodes and appends the string' do
+            valid_ascii_string = "abc".force_encoding("ASCII-8BIT")
+            valid_unicode_string = utf_8_euro_symbol.force_encoding('UTF-8')
+
+            resulting_string = build_encoded_string(valid_unicode_string, target_encoding) << valid_ascii_string
+            expect(resulting_string).to eq "#{utf_8_euro_symbol}abc".force_encoding('UTF-8')
+          end
+        end
+
+        context 'with a string that cannot be converted to the target encoding' do
+          it 'replaces undefined characters with either a ? or a unicode ?' do
+            ascii_string = ascii_arrow_symbol.force_encoding("ASCII-8BIT")
+            valid_unicode_string = utf_8_euro_symbol.force_encoding('UTF-8')
+
+            resulting_string = build_encoded_string(valid_unicode_string, target_encoding) << ascii_string
+            expected_bytes = utf_8_euro_symbol.each_byte.to_a + ["?".unpack("c").first]
+            actual_bytes = resulting_string.each_byte.to_a
+
+            expect(actual_bytes).to eq(expected_bytes)
+          end
+        end
+
+        context 'with two ascii strings with a target encoding of UTF-8 ' do
+          it 'has an encoding of UTF-8' do
+            ascii_string = 'abc'.force_encoding("ASCII-8BIT")
+            other_ascii_string = '123'.force_encoding("ASCII-8BIT")
+
+            resulting_string = build_encoded_string(ascii_string, target_encoding) << other_ascii_string
+            expect(resulting_string.encoding.to_s).to eq 'UTF-8'
+          end
+        end
+      end
+
+      describe '#split' do
+        it 'splits the string based on the delimiter accounting for encoding' do
+          wrapped_string = "aaaaaaaaaaa#{ascii_arrow_symbol}aaaaa".force_encoding("ASCII-8BIT")
+
+          expect {
+            build_encoded_string(wrapped_string, target_encoding).split(utf_8_euro_symbol.force_encoding("UTF-8"))
+          }.not_to raise_error
+        end
+      end
+
+      def build_encoded_string(string, target_encoding)
+        EncodedString.new(string, target_encoding)
+      end
+    else
+
+      describe '#source_encoding' do
+        it 'defaults to US-ASCII' do
+          str = EncodedString.new("abc", "UTF-8")
+          expect( str.source_encoding ).to eq('US-ASCII')
+        end
+      end
+    end
+  end
+end

data/rspec-support/spec/rspec/support/fuzzy_matcher_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+require 'rspec/support/fuzzy_matcher'
+
+module RSpec
+  module Support
+    describe FuzzyMatcher, ".values_match?" do
+      matcher :match_against do |actual|
+        match { |expected| FuzzyMatcher.values_match?(expected, actual) }
+      end
+
+      it 'returns true when given equal values' do
+        expect(1).to match_against(1.0)
+      end
+
+      it 'returns false when given unequal values that do not provide match logic' do
+        expect(1).not_to match_against(1.1)
+      end
+
+      it 'can match a regex against a string' do
+        expect(/foo/).to match_against("foobar")
+        expect(/foo/).not_to match_against("fobar")
+      end
+
+      it 'can match a regex against itself' do
+        expect(/foo/).to match_against(/foo/)
+        expect(/foo/).not_to match_against(/bar/)
+      end
+
+      it 'can match a class against an instance' do
+        expect(String).to match_against("foo")
+        expect(String).not_to match_against(123)
+      end
+
+      it 'can match a class against itself' do
+        expect(String).to match_against(String)
+        expect(String).not_to match_against(Regexp)
+      end
+
+      it 'can match against a matcher' do
+        expect(be_within(0.1).of(2)).to match_against(2.05)
+        expect(be_within(0.1).of(2)).not_to match_against(2.15)
+      end
+
+      it 'does not ask the second argument if it fuzzy matches (===)' do
+        expect("foo").not_to match_against(String)
+      end
+
+      context "when given two 0-arg lambdas" do
+        it 'returns true when given the same lambda' do
+          k = lambda { 3 }
+          expect(k).to match_against(k)
+        end
+
+        it 'returns false when given different lambdas' do
+          expect(lambda { 3 }).not_to match_against(lambda { 4 })
+        end
+      end
+
+      context "when given an object whose implementation of `==` raises an ArgumentError" do
+        it 'surfaces the error' do
+          klass = Class.new do
+            attr_accessor :foo
+            def ==(other)
+              other.foo == foo
+            end
+          end
+          instance = klass.new
+
+          other = Object.new
+          def other.foo(arg); end
+
+          expect { instance == other }.to raise_error(ArgumentError)
+          expect { FuzzyMatcher.values_match?(other, instance) }.to raise_error(ArgumentError)
+        end
+      end
+
+      it "does not match a struct against an array" do
+        struct = Struct.new(:foo, :bar).new("first", 2)
+        expect(["first", 2]).not_to match_against(struct)
+      end
+
+      context "when given two arrays" do
+        it 'returns true if they have equal values' do
+          expect([1, 2.0]).to match_against([1.0, 2])
+        end
+
+        it 'returns false when given unequal values that do not provide match logic' do
+          expect([1, 2.0]).not_to match_against([1.1, 2])
+        end
+
+        it 'does the fuzzy matching on the individual elements' do
+          expect([String, Fixnum]).to match_against(["a", 2])
+          expect([String, Fixnum]).not_to match_against([2, "a"])
+        end
+
+        it 'returns false if they have a different number of elements' do
+          expect([String, Fixnum]).not_to match_against(['a', 2, nil])
+        end
+
+        it 'supports arbitrary nested arrays' do
+          a1 = [
+            [String, Fixnum, [be_within(0.1).of(2)]],
+            3, [[[ /foo/ ]]]
+          ]
+
+          a2 = [
+            ["a", 1, [2.05]],
+            3, [[[ "foobar" ]]]
+          ]
+
+          expect(a1).to match_against(a2)
+          a2[0][2][0] += 1
+          expect(a1).not_to match_against(a2)
+        end
+      end
+
+      it 'can match an array an arbitrary enumerable' do
+        my_enum = Class.new do
+          include Enumerable
+
+          def each
+            yield 1; yield "foo"
+          end
+        end.new
+
+        expect([Fixnum, String]).to match_against(my_enum)
+        expect([String, Fixnum]).not_to match_against(my_enum)
+      end
+
+      context 'when given two hashes' do
+        it 'returns true when their keys and values are equal' do
+          expect(:a => 5, :b => 2.0).to match_against(:a => 5.0, :b => 2)
+        end
+
+        it 'returns false when given unequal values that do not provide match logic' do
+          expect(:a => 5).not_to match_against(:a => 5.1)
+        end
+
+        it 'does the fuzzy matching on the individual values' do
+          expect(:a => String, :b => /bar/).to match_against(:a => "foo", :b => "barn")
+          expect(:a => String, :b => /bar/).not_to match_against(:a => "foo", :b => "brn")
+        end
+
+        it 'returns false if the expected hash has nil values that are not in the actual hash' do
+          expect(:a => 'b', :b => nil).not_to match_against(:a => "b")
+        end
+
+        it 'returns false if actual hash has extra entries' do
+          expect(:a => 'b').not_to match_against(:a => "b", :b => nil)
+        end
+
+        it 'does not fuzzy match on keys' do
+          expect(/foo/ => 1).not_to match_against("foo" => 1)
+        end
+
+        it 'supports arbitrary nested hashes' do
+          h1 = {
+            :a => {
+              :b => [String, Fixnum],
+              :c => { :d => be_within(0.1).of(2) }
+            }
+          }
+
+          h2 = {
+            :a => {
+              :b => ["foo", 5],
+              :c => { :d => 2.05 }
+            }
+          }
+
+          expect(h1).to match_against(h2)
+          h2[:a][:c][:d] += 1
+          expect(h1).not_to match_against(h2)
+        end
+      end
+    end
+  end
+end
+

data/rspec-support/spec/rspec/support/method_signature_verifier_spec.rb

@@ -0,0 +1,357 @@
+require 'rspec/support'
+require 'rspec/support/method_signature_verifier'
+
+module RSpec
+  module Support
+    describe 'verifying methods' do
+      let(:signature) { MethodSignature.new(test_method) }
+
+      def valid_non_kw_args?(arity)
+        described_class.new(signature, [nil] * arity).valid?
+      end
+
+      def valid?(*args)
+        described_class.new(signature, args).valid?
+      end
+
+      def error_description
+        described_class.new(signature, []).error_message[/Expected (.*),/, 1]
+      end
+
+      def error_for(*args)
+        described_class.new(signature, args).error_message
+      end
+
+      def signature_description
+        signature.description
+      end
+
+      shared_context 'a method verifier' do
+        describe 'with a method with arguments' do
+          def arity_two(x, y); end
+
+          let(:test_method) { method(:arity_two) }
+
+          it 'covers only the exact arity' do
+            expect(valid_non_kw_args?(1)).to eq(false)
+            expect(valid_non_kw_args?(2)).to eq(true)
+            expect(valid_non_kw_args?(3)).to eq(false)
+          end
+
+          it "allows matchers to be passed as arguments" do
+            expect(valid?(anything, anything)).to eq(true)
+          end
+
+          it 'does not treat a last-arg hash as kw args' do
+            expect(valid?(1, {})).to eq(true)
+          end
+
+          it 'describes the arity precisely' do
+            expect(error_description).to eq("2")
+          end
+
+          it 'mentions only the arity in the description' do
+            expect(signature_description).to eq("arity of 2")
+          end
+        end
+
+        describe 'a method with splat arguments' do
+          def arity_splat(_, *); end
+
+          let(:test_method) { method(:arity_splat) }
+
+          it 'covers a range from the lower bound upwards' do
+            expect(valid_non_kw_args?(0)).to eq(false)
+            expect(valid_non_kw_args?(1)).to eq(true)
+            expect(valid_non_kw_args?(2)).to eq(true)
+            expect(valid_non_kw_args?(3)).to eq(true)
+          end
+
+          it 'describes the arity with no upper bound' do
+            expect(error_description).to eq("1 or more")
+          end
+
+          it 'mentions only the arity in the description' do
+            expect(signature_description).to eq("arity of 1 or more")
+          end
+        end
+
+        describe 'a method with optional arguments' do
+          def arity_optional(x, y, z = 1); end
+
+          let(:test_method) { method(:arity_optional) }
+
+          it 'covers a range from min to max possible arguments' do
+            expect(valid_non_kw_args?(1)).to eq(false)
+            expect(valid_non_kw_args?(2)).to eq(true)
+            expect(valid_non_kw_args?(3)).to eq(true)
+
+            if RubyFeatures.optional_and_splat_args_supported?
+              expect(valid_non_kw_args?(4)).to eq(false)
+            else
+              expect(valid_non_kw_args?(4)).to eq(true)
+            end
+          end
+
+          if RubyFeatures.optional_and_splat_args_supported?
+            it 'describes the arity as a range' do
+              expect(error_description).to eq("2 to 3")
+            end
+          else
+            it 'describes the arity with no upper bound' do
+              expect(error_description).to eq("2 or more")
+            end
+          end
+        end
+
+        if RubyFeatures.kw_args_supported?
+          describe 'a method with optional keyword arguments' do
+            eval <<-RUBY
+              def arity_kw(x, y:1, z:2); end
+            RUBY
+
+            let(:test_method) { method(:arity_kw) }
+
+            it 'does not require any of the arguments' do
+              expect(valid?(nil)).to eq(true)
+              expect(valid?(nil, nil)).to eq(false)
+            end
+
+            it 'does not allow an invalid keyword arguments' do
+              expect(valid?(nil, :a => 1)).to eq(false)
+            end
+
+            it 'mentions the invalid keyword args in the error', :pending => RUBY_ENGINE == 'jruby' do
+              expect(error_for(nil, :a => 0, :b => 1)).to \
+                eq("Invalid keyword arguments provided: a, b")
+            end
+
+            it 'describes invalid arity precisely' do
+              expect(error_for()).to \
+                eq("Wrong number of arguments. Expected 1, got 0.")
+            end
+
+            it 'does not blow up when given a BasicObject as the last arg' do
+              expect(valid?(BasicObject.new)).to eq(true)
+            end
+
+            it 'does not mutate the provided args array' do
+              args = [nil, { :y => 1 }]
+              described_class.new(signature, args).valid?
+              expect(args).to eq([nil, { :y => 1 }])
+            end
+
+            it 'mentions the arity and optional kw args in the description', :pending => RUBY_ENGINE == 'jruby' do
+              expect(signature_description).to eq("arity of 1 and optional keyword args (:y, :z)")
+            end
+          end
+        end
+
+        if RubyFeatures.required_kw_args_supported?
+          describe 'a method with required keyword arguments' do
+            eval <<-RUBY
+              def arity_required_kw(x, y:, z:, a: 'default'); end
+            RUBY
+
+            let(:test_method) { method(:arity_required_kw) }
+
+            it 'returns false unless all required keywords args are present' do
+              expect(valid?(nil, :a => 0, :y => 1, :z => 2)).to eq(true)
+              expect(valid?(nil, :a => 0, :y => 1)).to eq(false)
+              expect(valid?(nil, nil, :a => 0, :y => 1, :z => 2)).to eq(false)
+              expect(valid?(nil, nil)).to eq(false)
+            end
+
+            it 'mentions the missing required keyword args in the error' do
+              expect(error_for(nil, :a => 0)).to \
+                eq("Missing required keyword arguments: y, z")
+            end
+
+            it 'is described precisely when arity is wrong' do
+              expect(error_for(nil, nil, :z => 0, :y => 1)).to \
+                eq("Wrong number of arguments. Expected 1, got 2.")
+            end
+
+            it 'mentions the arity, optional kw args and required kw args in the description' do
+              expect(signature_description).to \
+                eq("arity of 1 and optional keyword args (:a) and required keyword args (:y, :z)")
+            end
+          end
+
+          describe 'a method with required keyword arguments and a splat' do
+            eval <<-RUBY
+              def arity_required_kw_splat(w, *x, y:, z:, a: 'default'); end
+            RUBY
+
+            let(:test_method) { method(:arity_required_kw_splat) }
+
+            it 'returns false unless all required keywords args are present' do
+              expect(valid?(nil, :a => 0, :y => 1, :z => 2)).to eq(true)
+              expect(valid?(nil, :a => 0, :y => 1)).to eq(false)
+              expect(valid?(nil, nil, :a => 0, :y => 1, :z => 2)).to eq(true)
+              expect(valid?(nil, nil, nil)).to eq(false)
+              expect(valid?).to eq(false)
+            end
+
+            it 'mentions missing required keyword args in the error' do
+              expect(error_for(nil, :y => 1)).to \
+                eq("Missing required keyword arguments: z")
+            end
+
+            it 'mentions the arity, optional kw args and required kw args in the description' do
+              expect(signature_description).to \
+                eq("arity of 1 or more and optional keyword args (:a) and required keyword args (:y, :z)")
+            end
+          end
+
+          describe 'a method with required keyword arguments and a keyword arg splat' do
+            eval <<-RUBY
+              def arity_kw_arg_splat(x:, **rest); end
+            RUBY
+
+            let(:test_method) { method(:arity_kw_arg_splat) }
+
+            it 'allows extra undeclared keyword args' do
+              expect(valid?(:x => 1)).to eq(true)
+              expect(valid?(:x => 1, :y => 2)).to eq(true)
+            end
+
+            it 'mentions missing required keyword args in the error' do
+              expect(error_for(:y => 1)).to \
+                eq("Missing required keyword arguments: x")
+            end
+
+            it 'mentions the required kw args and keyword splat in the description' do
+              expect(signature_description).to \
+                eq("required keyword args (:x) and any additional keyword args")
+            end
+          end
+
+          describe 'a method with a required arg and a keyword arg splat' do
+            eval <<-RUBY
+              def arity_kw_arg_splat(x, **rest); end
+            RUBY
+
+            let(:test_method) { method(:arity_kw_arg_splat) }
+
+            it 'allows a single arg and any number of keyword args' do
+              expect(valid?(nil)).to eq(true)
+              expect(valid?(nil, :x => 1)).to eq(true)
+              expect(valid?(nil, :x => 1, :y => 2)).to eq(true)
+              expect(valid?(:x => 1)).to eq(true)
+
+              expect(valid?).to eq(false)
+              expect(valid?(nil, nil)).to eq(false)
+              expect(valid?(nil, nil, :x => 1)).to eq(false)
+            end
+
+            it 'describes the arity precisely' do
+              expect(error_for()).to \
+                eq("Wrong number of arguments. Expected 1, got 0.")
+            end
+
+            it 'mentions the required kw args and keyword splat in the description' do
+              expect(signature_description).to \
+                eq("arity of 1 and any additional keyword args")
+            end
+          end
+        end
+
+        describe 'a method with a block' do
+          def arity_block(_, &block); end
+
+          let(:test_method) { method(:arity_block) }
+
+          it 'does not count the block as a parameter' do
+            expect(valid_non_kw_args?(1)).to eq(true)
+            expect(valid_non_kw_args?(2)).to eq(false)
+          end
+
+          it 'describes the arity precisely' do
+            expect(error_description).to eq("1")
+          end
+        end
+      end
+
+      let(:fake_matcher) { Object.new }
+      let(:fake_matcher_def) { lambda {|x| fake_matcher == x }}
+
+      before do
+        RSpec::Support.register_matcher_definition(&fake_matcher_def)
+      end
+
+      after do
+        RSpec::Support.deregister_matcher_definition(&fake_matcher_def)
+      end
+
+
+      describe StrictSignatureVerifier do
+        it_behaves_like 'a method verifier'
+
+        if RubyFeatures.kw_args_supported?
+          describe 'providing a matcher for optional keyword arguments' do
+            eval <<-RUBY
+              def arity_kw(x, y:1); end
+            RUBY
+
+            let(:test_method) { method(:arity_kw) }
+
+            it 'is not allowed' do
+              expect(valid?(nil, fake_matcher)).to eq(false)
+            end
+          end
+        end
+
+        if RubyFeatures.required_kw_args_supported?
+          describe 'providing a matcher for required keyword arguments' do
+            eval <<-RUBY
+              def arity_kw_required(x, y:); end
+            RUBY
+
+            let(:test_method) { method(:arity_kw_required) }
+
+            it 'is not allowed' do
+              expect(valid?(nil, fake_matcher)).to eq(false)
+            end
+          end
+        end
+      end
+
+      describe LooseSignatureVerifier do
+        it_behaves_like 'a method verifier'
+
+        if RubyFeatures.kw_args_supported?
+          describe 'for optional keyword arguments' do
+            eval <<-RUBY
+              def arity_kw(x, y:1, z:2); end
+            RUBY
+
+            let(:test_method) { method(:arity_kw) }
+
+            it 'allows a matcher' do
+              expect(valid?(nil, fake_matcher)).to eq(true)
+            end
+
+            it 'allows a matcher only for positional arguments' do
+              expect(valid?(fake_matcher)).to eq(true)
+            end
+          end
+        end
+
+        if RubyFeatures.required_kw_args_supported?
+          describe 'providing a matcher for required keyword arguments' do
+            eval <<-RUBY
+              def arity_kw_required(x, y:); end
+            RUBY
+
+            let(:test_method) { method(:arity_kw_required) }
+
+            it 'is allowed' do
+              expect(valid?(nil, fake_matcher)).to eq(true)
+            end
+          end
+        end
+      end
+    end
+  end
+end