lookout 2.3.0 → 3.0.0

data/test/unit/lookout-3.0/difference/module.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect 'Module≠Enumerable' do
+    Enumerable.to_lookout_expected.difference(Module).message
+  end
+
+  expect '1≉Enumerable' do
+    Enumerable.to_lookout_expected.difference(1).message
+  end
+end

data/test/unit/lookout-3.0/difference/object.rb

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect '2≠1' do
+    1.to_lookout_expected.difference(2).message
+  end
+
+  expect '(cannot inspect actual result: error)≠nil' do
+    nil.to_lookout_expected.difference(stub(:inspect => proc{ raise 'error' })).message
+  end
+
+  expect 'nil≠(cannot inspect expected value: error)' do
+    Lookout::Expected::Object.new(stub(:inspect => proc{ raise 'error' })).difference(nil).message
+  end
+
+  expect '2≠1 (cannot generate more specific failure message: error)' do
+    Class.new(Lookout::Difference::Object){
+      def message
+        raise 'error'
+      end
+    }.new(2, 1).to_s
+  end
+
+  expect '2≠1: (cannot diff expected value and actual result: error)' do
+    Class.new(Lookout::Difference::Object){
+      def diff
+        raise 'error'
+      end
+    }.new(2, 1).to_s
+  end
+end

data/test/unit/lookout-3.0/difference/range.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect '0..2≠0..1' do
+    (0..1).to_lookout_expected.difference((0..2)).message
+  end
+
+  expect '2∉0..1' do
+    (0..1).to_lookout_expected.difference(2).message
+  end
+end

data/test/unit/lookout-3.0/difference/regexp.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect '/b/≠/a/' do
+    /a/.to_lookout_expected.difference(/b/).message
+  end
+
+  expect '"b"≉/a/' do
+    /a/.to_lookout_expected.difference('b').message
+  end
+end

data/test/unit/lookout-3.0/difference/string.rb

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect [] do
+    'a'.to_lookout_expected.difference(1).diff
+  end
+
+  expect '[-b-]{+a+}' do
+    'a'.to_lookout_expected.difference('b').diff.to_s
+  end
+
+  expect <<EOF.chomp do
+@@ -1,2 +1,1 @@
+-b
+-c
++a
+EOF
+    'a'.to_lookout_expected.difference("b\nc").diff.to_s
+  end
+
+  expect <<EOF.chomp do
+@@ -1,1 +1,2 @@
+-c
++a
++b
+EOF
+    "a\nb".to_lookout_expected.difference("c").diff.to_s
+  end
+end

data/test/unit/lookout-3.0/difference/symbol.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect '¬"a"#empty?' do
+    :empty?.to_lookout_expected.difference('a').message
+  end
+
+  expect '""#empty?' do
+    :not_empty?.to_lookout_expected.difference('').message
+  end
+end

data/test/unit/lookout-3.0/encode.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect 'a' do
+    Lookout::Encode.new('a').call
+  end
+
+  expect 'a' do
+    '%s' % Lookout::Encode.new('a')
+  end
+
+  expect 'a' do
+    [Lookout::Encode.new('a')].join('')
+  end
+
+  expect 'a' do
+    a = 'a'
+    class << a; undef encode end if a.respond_to? :encode
+    Lookout::Encode.new(a).call
+  end
+
+  if 'a'.respond_to? :encode
+    expect Encoding::UTF_8 do
+      a = 'a'.force_encoding('ASCII-8BIT')
+      Lookout::Encode.new(a).call.encoding
+    end
+  end
+end

data/test/unit/lookout-3.0/exception.rb

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect 'error' do
+    Lookout::Exception.new(RuntimeError.new('error')).message
+  end
+
+  if ''.respond_to? :encode
+    expect "cannot retrieve error message: error" do
+      Lookout::Exception.new(stub(:to_str => proc{ raise 'error' })).message
+    end
+
+    expect "cannot retrieve error message: can't convert Lookout::Stub to String (Lookout::Stub#to_s gives NilClass)" do
+      Lookout::Exception.new(stub(:to_str => nil, :to_s => nil)).message
+    end
+
+    expect 'cannot encode error message for output: "\xE2" from ASCII-8BIT to UTF-8; dumping instead: "can\xE2\x80\x99t"' do
+      Lookout::Exception.new(stub(:to_str => 'can’t'.force_encoding('ASCII-8BIT'))).message
+    end
+
+    expect 'cannot encode error message for output: "\xE2" from ASCII-8BIT to UTF-8' do
+      stub('can’t'.force_encoding('ASCII-8BIT'), :dump => proc{ raise 'error' }){ |message|
+        Lookout::Exception.new(stub(:to_str => message)).message
+      }
+    end
+  end
+
+  expect 'unhandled exception' do
+    stub(RuntimeError.new(''), :message => proc{ raise 'inner' }){ |exception|
+      Lookout::Exception.new(exception).header
+    }
+  end
+
+  expect 'unhandled exception' do
+    Lookout::Exception.new(RuntimeError.new('')).header
+  end
+
+  expect 'unhandled exception' do
+    Lookout::Exception.new(RuntimeError.new("\n")).header
+  end
+
+  expect 'StandardError' do
+    Lookout::Exception.new(StandardError.new('')).header
+  end
+
+  expect 'error' do
+    stub(Class.new(StandardError).new('error'), :class => stub(:name => nil)){ |exception|
+      Lookout::Exception.new(exception).header
+    }
+  end
+
+  expect 'error (cannot determine name of class of exception: inner)' do
+    stub(Class.new(StandardError).new('error'), :class => stub(:name => proc{ raise 'inner' })){ |exception|
+      Lookout::Exception.new(exception).header
+    }
+  end
+
+  expect 'error' do
+    Lookout::Exception.new(Class.new(StandardError).new('error')).header
+  end
+
+  expect 'error' do
+    Lookout::Exception.new(Class.new(StandardError).new("error\n")).header
+  end
+
+  expect 'error (StandardError)' do
+    Lookout::Exception.new(StandardError.new('error')).header
+  end
+
+  expect 'error (StandardError)' do
+    Lookout::Exception.new(StandardError.new("error\n")).header
+  end
+
+  expect "line 1 (StandardError)\nline 2\nline 3" do
+    Lookout::Exception.new(StandardError.new("line 1\nline 2\nline 3")).header
+  end
+
+  expect StandardError do
+    Lookout::Exception.new(StandardError.new).type
+  end
+
+  expect Lookout::Exception::Unknown do
+    stub(StandardError.new('error'), :class => proc{ raise 'inner' }){ |exception|
+      Lookout::Exception.new(exception).type
+    }
+  end
+
+  expect 'StandardError' do
+    Lookout::Exception.new(StandardError.new).type_name
+  end
+
+  expect 'cannot determine name of class of exception: inner' do
+    stub(StandardError.new('error'), :class => stub(:name => proc{ raise 'inner' })){ |exception|
+      Lookout::Exception.new(exception).type_name
+    }
+  end
+
+  expect 'cannot determine name of class of exception: cannot determine class of exception: inner' do
+    stub(StandardError.new('error'), :class => proc{ raise 'inner' }){ |exception|
+      Lookout::Exception.new(exception).type_name
+    }
+  end
+
+  expect "line 1 (StandardError)\nline 2\n\tfrom a:1\n\tfrom b:2" do
+    Lookout::Exception.new(StandardError.new("line 1\nline 2").tap{ |e| e.set_backtrace ['a:1', 'b:2'] }).format
+  end
+end

data/test/unit/lookout-3.0/exception/backtrace.rb

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect '' do
+    Lookout::Exception::Backtrace.from(nil).to_s
+  end
+
+  expect '' do
+    Lookout::Exception::Backtrace.from(stub(:backtrace => nil)).to_s
+  end
+
+  expect "\tfrom 1
+\tfrom 2
+\tfrom 3
+\tfrom 4
+\tfrom 5
+\tfrom 6
+\tfrom 7
+\tfrom 8
+\t ... 6 levels ...
+\tfrom A
+\tfrom B
+\tfrom C
+\tfrom D
+\tfrom E" do
+    Lookout::Exception::Backtrace.
+      from(SystemStackError.new('error').tap{ |e|
+             e.set_backtrace %w[1 2 3 4 5 6 7 8 a b c d e f A B C D E]
+           }).to_s
+  end
+
+  expect "\tfrom a:1" do
+    Lookout::Exception::Backtrace.new('a:1', false).to_s
+  end
+
+  expect "\tfrom a:1\n\tfrom b:2" do
+    Lookout::Exception::Backtrace.new(%w'a:1 b:2', false).to_s
+  end
+
+  expect "\tfrom (cannot retrieve backtrace entry: error)" do
+    stub('a:1', :encode => proc{ raise 'error' }){ |entry|
+      Lookout::Exception::Backtrace.new([entry], false).to_s
+    }
+  end
+
+  expect "\tfrom a:1\n\tfrom (cannot retrieve backtrace entry: error)\n\tfrom c:3" do
+    stub('b:2', :encode => proc{ raise 'error' }){ |entry|
+      Lookout::Exception::Backtrace.new(['a:1', entry, 'c:3'], false).to_s
+    }
+  end
+
+  expect "\tfrom (backtrace is not an Array of String: 1)" do
+    Lookout::Exception::Backtrace.new(1, false).to_s
+  end
+
+  expect "\tfrom a:1\n\tfrom b:2" do
+    Lookout::Exception::Backtrace.
+      new(['a:1',
+           'b:2',
+           File.join(Lookout::Exception::Backtrace::Root, 'c:3'),
+           'd:4'],
+          false,
+          true).to_s
+  end
+
+  expect "\tfrom b:2\n\tfrom c:3\n\tfrom d:4" do
+    Lookout::Exception::Backtrace.
+      new([File.join(Lookout::Exception::Backtrace::Root, 'a:1'),
+           'b:2',
+           'c:3',
+           'd:4'],
+          false,
+          true).to_s
+  end
+end

data/test/unit/lookout-3.0/exception/unknown.rb

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect RuntimeError.new('cannot determine class of exception: inner') do
+    Lookout::Exception::Unknown.new(RuntimeError.new('inner')).name
+  end
+
+  expect RuntimeError.new('cannot determine class of exception: cannot retrieve error message: inner') do
+    stub(RuntimeError.new, :message => proc{ raise 'inner' }){ |exception|
+      Lookout::Exception::Unknown.new(exception).name
+    }
+  end
+
+  expect '(cannot determine class of exception: inner)' do
+    Lookout::Exception::Unknown.new(RuntimeError.new('inner')).inspect
+  end
+
+  expect '(cannot determine class of exception: cannot retrieve error message: inner)' do
+    stub(RuntimeError.new, :message => proc{ raise 'inner' }){ |exception|
+      Lookout::Exception::Unknown.new(exception).inspect
+    }
+  end
+end

data/test/unit/lookout-3.0/expect.rb

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect Lookout::Expect::Exception do
+    Lookout::Expect.expect(StandardError.new, 'test', 1)
+  end
+
+  expect NoMethodError do
+    Lookout::Aphonic.new.to_lookout_expected
+  end
+
+  expect Lookout::Expect::Object do
+    Lookout::Expect.expect(Lookout::Aphonic.new, 'test', 1)
+  end
+end

data/test/unit/lookout-3.0/expect/classes/exception.rb

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect Lookout::Expect::Classes::Exception do
+    SystemExit.to_lookout_expected.expect('test', 1){ exit }
+  end
+
+  expect Lookout::Results::Success.new('test', 1) do
+    begin
+      SystemExit.to_lookout_expected.expect('test', 1){ exit }.call
+    rescue SystemExit
+      raise 'SystemExit not caught'
+    end
+  end
+
+  expect Lookout::Results::Success.new('test', 1) do
+    StandardError.to_lookout_expected.expect('test', 1){ raise 'error' }.call
+  end
+
+  expect Lookout::Results::Success.new('test', 1) do
+    RuntimeError.to_lookout_expected.expect('test', 1){ raise 'error' }.call
+  end
+
+  expect Lookout::Results::Error do
+    ArgumentError.to_lookout_expected.expect('test', 1){ raise 'error' }.call
+  end
+
+  expect Lookout::Results::Failure.new('test', 1, Lookout::Difference::Object.new(nil, RuntimeError)) do
+    RuntimeError.to_lookout_expected.expect('test', 1){ nil }.call
+  end
+
+  expect Lookout::Results::Error do
+    ArgumentError.to_lookout_expected.expect('test', 1){
+      raise Class.new(RuntimeError){
+        def class
+          raise 'no class for you'
+        end
+      }
+    }.call
+  end
+end

data/test/unit/lookout-3.0/expect/exception.rb

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect Lookout::Expect::Exception do
+    RuntimeError.new('error').to_lookout_expected.expect('test', 1)
+  end
+
+  expect Lookout::Results::Success.new('test', 1) do
+    RuntimeError.new('error').to_lookout_expected.expect('test', 1){ raise 'error' }.call
+  end
+
+  expect Lookout::Results::Failure.
+    new('test',
+        1,
+        Lookout::Difference::Exception.new(RuntimeError.new('b'),
+                                           RuntimeError.new('a'))) do
+    RuntimeError.new('a').to_lookout_expected.expect('test', 1){ raise 'b' }.call
+  end
+
+  expect Lookout::Results::Error do
+    StandardError.new('a').to_lookout_expected.expect('test', 1){ raise 'b' }.call
+  end
+
+  expect 'RuntimeError≠StandardError' do
+    StandardError.new('a').to_lookout_expected.expect('test', 1){ raise 'b' }.call.message
+  end
+
+  expect Lookout::Results::Error do
+    RuntimeError.new.to_lookout_expected.expect('test', 1){
+      raise Class.new(RuntimeError){
+        def class
+          raise 'no class for you'
+        end
+      }
+    }.call
+  end
+
+  expect '(cannot determine class of exception: no class for you)≠RuntimeError' do
+    RuntimeError.new.to_lookout_expected.expect('test', 1){
+      raise Class.new(RuntimeError){
+        def class
+          raise 'no class for you'
+        end
+      }
+    }.call.message
+  end
+
+  expect Lookout::Results::Error do
+    Class.new(RuntimeError){
+      def class
+        raise 'no class for you'
+      end
+    }.new('a').to_lookout_expected.expect('test', 1){ raise 'b' }.call
+  end
+
+  expect 'RuntimeError≠Exception' do
+    Class.new(RuntimeError){
+      def class
+        raise 'no class for you'
+      end
+    }.new('a').to_lookout_expected.expect('test', 1){ raise 'b' }.call.message
+  end
+end