opal-rspec 0.6.2 → 0.7.0.rc.1

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

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

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

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

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