opal-rspec 0.4.3 → 0.5.0.beta1

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

@@ -0,0 +1,322 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'ostruct'
+require 'timeout'
+require 'rspec/support/differ'
+
+module RSpec
+  module Support
+    describe Differ do
+      describe '#diff' do
+        let(:differ) { RSpec::Support::Differ.new }
+
+        it "outputs unified diff of two strings" do
+          expected = "foo\nzap\nbar\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nanother\nline\n"
+          actual   = "foo\nbar\nzap\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nline\n"
+
+          expected_diff = <<-'EOD'
+
+
+@@ -1,6 +1,6 @@
+ foo
+-zap
+ bar
++zap
+ this
+ is
+ soo
+@@ -9,6 +9,5 @@
+ equal
+ insert
+ a
+-another
+ line
+EOD
+
+          diff = differ.diff(actual, expected)
+          expect(diff).to eql(expected_diff)
+        end
+
+        if String.method_defined?(:encoding)
+          it "returns an empty string if strings are not multiline" do
+            expected = "Tu avec carte {count} item has".encode('UTF-16LE')
+            actual   = "Tu avec carté {count} itém has".encode('UTF-16LE')
+
+            expect(differ.diff(actual, expected)).to be_empty
+          end
+
+          it 'copes with encoded strings' do
+            expected = "Tu avec carte {count} item has\n".encode('UTF-16LE')
+            actual   = "Tu avec carté {count} itém has\n".encode('UTF-16LE')
+            expect(differ.diff(actual, expected)).to eql(<<-EOD.encode('UTF-16LE'))
+
+@@ -1,2 +1,2 @@
+-Tu avec carte {count} item has
++Tu avec carté {count} itém has
+EOD
+          end
+
+          it 'handles differently encoded strings that are compatible' do
+            expected = "abc\n".encode('us-ascii')
+            actual   = "강인철\n".encode('UTF-8')
+            expect(differ.diff(actual, expected)).to eql "\n@@ -1,2 +1,2 @@\n-abc\n+강인철\n"
+          end
+
+          it 'uses the default external encoding when the two strings have incompatible encodings' do
+            expected = "Tu avec carte {count} item has\n"
+            actual   = "Tu avec carté {count} itém has\n".encode('UTF-16LE')
+            expect(differ.diff(actual, expected)).to eq("\n@@ -1,2 +1,2 @@\n-Tu avec carte {count} item has\n+Tu avec carté {count} itém has\n")
+            expect(differ.diff(actual, expected).encoding).to eq(Encoding.default_external)
+          end
+
+          it 'handles any encoding error that occurs with a helpful error message' do
+            expect(RSpec::Support::HunkGenerator).to receive(:new).
+              and_raise(Encoding::CompatibilityError)
+            expected = "Tu avec carte {count} item has\n".encode('us-ascii')
+            actual   = "Tu avec carté {count} itém has\n"
+            diff = differ.diff(actual, expected)
+            expect(diff).to match(/Could not produce a diff/)
+            expect(diff).to match(/actual string \(UTF-8\)/)
+            expect(diff).to match(/expected string \(US-ASCII\)/)
+          end
+        end
+
+        it "outputs unified diff message of two objects" do
+          animal_class = Class.new do
+            def initialize(name, species)
+              @name, @species = name, species
+            end
+
+            def inspect
+              <<-EOA
+<Animal
+  name=#{@name},
+  species=#{@species}
+>
+              EOA
+            end
+          end
+
+          expected = animal_class.new "bob", "giraffe"
+          actual   = animal_class.new "bob", "tortoise"
+
+          expected_diff = <<'EOD'
+
+@@ -1,5 +1,5 @@
+ <Animal
+   name=bob,
+-  species=tortoise
++  species=giraffe
+ >
+EOD
+
+          diff = differ.diff(expected,actual)
+          expect(diff).to eq expected_diff
+        end
+
+        it "outputs unified diff message of two arrays" do
+          expected = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'charlie', :width, 'quite wide' ]
+          actual   = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'tango'  , :width, 'very wide'  ]
+
+          expected_diff = <<'EOD'
+
+
+@@ -5,7 +5,7 @@
+  :metasyntactic,
+  "variable",
+  :delta,
+- "tango",
++ "charlie",
+  :width,
+- "very wide"]
++ "quite wide"]
+EOD
+
+          diff = differ.diff(expected,actual)
+          expect(diff).to eq expected_diff
+        end
+
+        it 'outputs a unified diff message for an array which flatten recurses' do
+          klass = Class.new do
+            def to_ary; [self]; end
+            def inspect; "<BrokenObject>"; end
+          end
+          obj = klass.new
+
+          diff = ''
+          Timeout::timeout(1) do
+            diff = differ.diff [obj], []
+          end
+
+          expect(diff).to eq <<-EOD
+
+@@ -1,2 +1,2 @@
+-[]
++[<BrokenObject>]
+EOD
+        end
+
+        it "outputs unified diff message of two hashes" do
+          expected = { :foo => 'bar', :baz => 'quux', :metasyntactic => 'variable', :delta => 'charlie', :width =>'quite wide' }
+          actual   = { :foo => 'bar', :metasyntactic => 'variable', :delta => 'charlotte', :width =>'quite wide' }
+
+          expected_diff = <<'EOD'
+
+@@ -1,4 +1,5 @@
+-:delta => "charlotte",
++:baz => "quux",
++:delta => "charlie",
+ :foo => "bar",
+ :metasyntactic => "variable",
+ :width => "quite wide",
+EOD
+
+          diff = differ.diff(expected,actual)
+          expect(diff).to eq expected_diff
+        end
+
+        it 'outputs unified diff message of two hashes with differing encoding' do
+          expected_diff = %Q{
+@@ -1,2 +1,2 @@
+-"a" => "a",
+#{ (RUBY_VERSION.to_f > 1.8) ?  %Q{+"ö" => "ö"} : '+"\303\266" => "\303\266"' },
+}
+
+          diff = differ.diff({'ö' => 'ö'}, {'a' => 'a'})
+          expect(diff).to eq expected_diff
+        end
+
+        it 'outputs unified diff message of two hashes with encoding different to key encoding' do
+          expected_diff = %Q{
+@@ -1,2 +1,2 @@
+-:a => "a",
+#{ (RUBY_VERSION.to_f > 1.8) ?  %Q{+\"한글\" => \"한글2\"} : '+"\355\225\234\352\270\200" => "\355\225\234\352\270\2002"' },
+}
+
+          diff = differ.diff({ "한글" => "한글2"}, { :a => "a"})
+          expect(diff).to eq expected_diff
+        end
+
+        it "outputs unified diff message of two hashes with object keys" do
+          expected_diff = %Q{
+@@ -1,2 +1,2 @@
+-["a", "c"] => "b",
++["d", "c"] => "b",
+}
+
+          diff = differ.diff({ ['d','c'] => 'b'}, { ['a','c'] => 'b' })
+          expect(diff).to eq expected_diff
+        end
+
+        it "outputs unified diff of multi line strings" do
+          expected = "this is:\n  one string"
+          actual   = "this is:\n  another string"
+
+          expected_diff = <<'EOD'
+
+@@ -1,3 +1,3 @@
+ this is:
+-  another string
++  one string
+EOD
+
+          diff = differ.diff(expected,actual)
+          expect(diff).to eq expected_diff
+        end
+
+        it "splits items with newlines" do
+          expected_diff = <<'EOD'
+
+@@ -1,3 +1 @@
+-a\nb
+-c\nd
+EOD
+
+          diff = differ.diff [], ["a\nb", "c\nd"]
+          expect(diff).to eql expected_diff
+        end
+
+        it "shows inner arrays on a single line" do
+          expected_diff = <<'EOD'
+
+@@ -1,3 +1 @@
+-a\nb
+-["c\nd"]
+EOD
+
+          diff = differ.diff [], ["a\nb", ["c\nd"]]
+          expect(diff).to eql expected_diff
+        end
+
+        it "returns an empty string if no expected or actual" do
+          diff = differ.diff nil, nil
+
+          expect(diff).to be_empty
+        end
+
+        it "returns an empty string if expected is Numeric" do
+          diff = differ.diff 1, "2"
+
+          expect(diff).to be_empty
+        end
+
+        it "returns an empty string if actual is Numeric" do
+          diff = differ.diff "1", 2
+
+          expect(diff).to be_empty
+        end
+
+        it "returns an empty string if expected or actual are procs" do
+          diff = differ.diff lambda {}, lambda {}
+
+          expect(diff).to be_empty
+        end
+
+        it "returns a String if no diff is returned" do
+          diff = differ.diff 1, 2
+          expect(diff).to be_a(String)
+        end
+
+        it "returns a String if a diff is performed" do
+          diff = differ.diff "a\n", "b\n"
+          expect(diff).to be_a(String)
+        end
+
+        context "with :object_preparer option set" do
+          let(:differ) do
+            RSpec::Support::Differ.new(:object_preparer => lambda { |s| s.to_s.reverse })
+          end
+
+          it "uses the output of object_preparer for diffing" do
+            expected = :foo
+            actual = :poo
+
+            expected_diff = dedent(<<-EOS)
+              |
+              |@@ -1,2 +1,2 @@
+              |-"oop"
+              |+"oof"
+              |
+            EOS
+
+            diff = differ.diff(expected, actual)
+            expect(diff).to eq expected_diff
+          end
+        end
+
+        context "with :color option set" do
+          let(:differ) { RSpec::Support::Differ.new(:color => true) }
+
+          it "outputs colored diffs" do
+            expected = "foo bar baz\n"
+            actual = "foo bang baz\n"
+            expected_diff = "\e[0m\n\e[0m\e[34m@@ -1,2 +1,2 @@\n\e[0m\e[31m-foo bang baz\n\e[0m\e[32m+foo bar baz\n\e[0m"
+
+            diff = differ.diff(expected,actual)
+            expect(diff).to eq expected_diff
+          end
+        end
+      end
+    end
+  end
+end

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
+