tiramisu 0.0.0 → 0.0.1

data/lib/tiramisu/util.rb

@@ -0,0 +1,91 @@
+module Tiramisu
+
+  def call_block block
+    {returned: block.call, caller: relative_source_location(block)}.freeze
+  rescue UncaughtThrowError => e
+    {raised: e, thrown: extract_thrown_symbol(e), caller: relative_source_location(block)}.freeze
+  rescue Exception => e
+    {raised: e, caller: relative_source_location(block)}.freeze
+  end
+
+  # extract thrown symbol from given exception
+  #
+  # @param exception
+  #
+  def extract_thrown_symbol exception
+    return unless exception.is_a?(Exception)
+    return unless s = exception.message.scan(/uncaught throw\W+(\w+)/).flatten[0]
+    s.to_sym
+  end
+
+  def identity_string type, label, block
+    '%s %s (%s:%s)' % [
+      blue(type),
+      label.inspect,
+      *relative_source_location(block)
+    ]
+  end
+
+  def relative_source_location block
+    return unless block
+    [
+      relative_location(block.source_location[0]),
+      block.source_location[1]
+    ]
+  end
+
+  def relative_location line
+    line.sub(/\A#{pwd}\/+/, '')
+  end
+
+  def pretty_backtrace e
+    Array(e.backtrace).map {|l| relative_location(l)}
+  end
+
+  def readline caller
+    file, line = caller_to_source_location(caller)
+    return unless file && line
+    lines = ((@__readlinecache__ ||= {})[file] ||= File.readlines(file))
+    return unless line = lines[line.to_i - 1]
+    line.sub(/(do|\{)\Z/, '').strip
+  end
+
+  def caller_to_source_location caller
+    file, line = caller.split(/:(\d+):in.+/)
+    [relative_location(file), line]
+  end
+
+  def load_files pattern_or_files
+    files = pattern_or_files.is_a?(Array) ? pattern_or_files : Dir[pwd(pattern_or_files)]
+    files.each {|f| load_file(f)}
+  end
+
+  def load_file file
+    augment_load_path(file)
+    require(file)
+  end
+
+  def augment_load_path file
+    # adding ./
+    $:.unshift(pwd) unless $:.include?(pwd)
+
+    # adding ./lib/
+    lib = pwd('lib')
+    unless $:.include?(lib)
+      $:.unshift(lib) if File.directory?(lib)
+    end
+
+    # adding file's dirname
+    dir = File.dirname(file)
+    $:.unshift(dir) unless $:.include?(dir)
+  end
+
+  def pwd *args
+    File.join(Dir.pwd, *args.map!(&:to_s))
+  end
+end
+
+require 'tiramisu/util/assert_raise'
+require 'tiramisu/util/refute_raise'
+require 'tiramisu/util/assert_throw'
+require 'tiramisu/util/refute_throw'

data/lib/tiramisu/util/assert_raise.rb

@@ -0,0 +1,54 @@
+module Tiramisu
+
+  def assert_raised_as_expected object, expected_type = nil, expected_message = nil, block = nil
+    f = assert_raised(object)
+    return f if f
+
+    return assert_raised_as_expected_by_block(object, block) if block
+
+    if expected_type
+      f = assert_raised_expected_type(object, expected_type)
+      return f if f
+    end
+
+    if expected_message
+      f = assert_raised_expected_message(object, expected_message)
+      return f if f
+    end
+    nil
+  end
+
+  def assert_raised object
+    return [
+      'Expected a exception to be raised at %s' % object[:caller]
+    ] unless object[:raised]
+    nil
+  end
+
+  def assert_raised_as_expected_by_block object, block
+    return [
+      'Looks like wrong or no error raised at %s' % object[:caller],
+      'See validation block'
+    ] unless block.call(object[:raised])
+    nil
+  end
+
+  def assert_raised_expected_type object, expected_type
+    return [
+      'Expected a %s to be raised at %s' % [expected_type, object[:caller]],
+      'Instead a %s raised' % object[:raised].class
+    ] unless object[:raised].class == expected_type
+    nil
+  end
+
+  def assert_raised_expected_message object, expected_message
+    regexp = expected_message.is_a?(Regexp) ? expected_message : /\A#{expected_message}\z/
+    return [
+      'Expected the exception raised at %s' % object[:caller],
+      'to match "%s"' % regexp.source,
+      'Instead it looks like',
+      pp(object[:raised].message)
+    ] unless object[:raised].message =~ regexp
+    nil
+  end
+end

data/lib/tiramisu/util/assert_throw.rb

@@ -0,0 +1,40 @@
+module Tiramisu
+
+  def assert_thrown_as_expected object, expected_symbol = nil, block = nil
+    f = assert_thrown(object)
+    return f if f
+
+    return assert_thrown_as_expected_by_block(object, block) if block
+
+    if expected_symbol
+      f = assert_expected_symbol_thrown(object, expected_symbol)
+      return f if f
+    end
+    nil
+  end
+
+  def assert_thrown_as_expected_by_block object, block
+    return [
+      'Looks like wrong or no symbol thrown at %s' % object[:caller],
+      'See validating block'
+    ] unless block.call(object[:thrown])
+    nil
+  end
+
+  def assert_thrown object
+    return [
+      'Expected a symbol to be thrown at %s' % object[:caller]
+    ] unless object[:thrown]
+    nil
+  end
+
+  def assert_expected_symbol_thrown object, expected_symbol
+    return begin
+      [
+        'Expected :%s to be thrown at %s' % [expected_symbol, object[:caller]],
+        'Instead :%s thrown' % object[:thrown]
+      ]
+    end unless expected_symbol == object[:thrown]
+    nil
+  end
+end

data/lib/tiramisu/util/refute_raise.rb

@@ -0,0 +1,48 @@
+module Tiramisu
+
+  def refute_raised_as_expected object, expected_type, expected_message, block = nil
+    f = refute_raised(object, expected_type || expected_message)
+    return f if f
+
+    if expected_type
+      f = refute_raised_expected_type(object, expected_type)
+      return f if f
+    end
+
+    if expected_message
+      f = refute_raised_expected_message(object, expected_message)
+      return f if f
+    end
+    nil
+  end
+
+  def refute_raised object, should_raise = false
+    if should_raise
+      return [
+        'Expected a exception to be raised at %s' % object[:caller]
+      ] unless object[:raised]
+    else
+      return [
+        'A unexpected exception raised at %s' % object[:caller],
+        object[:raised]
+      ] if object[:raised]
+    end
+    nil
+  end
+
+  def refute_raised_expected_type object, expected_type
+    return [
+      'Not expected a %s to be raised at %s' % [object[:raised].class, object[:caller]],
+    ] if object[:raised].class == expected_type
+    nil
+  end
+
+  def refute_raised_expected_message object, expected_message
+    regexp = expected_message.is_a?(Regexp) ? expected_message : /\A#{expected_message}\z/
+    return [
+      'Not expected raised exception to match %s' % regexp.source,
+      object[:raised]
+    ] if object[:raised].message =~ regexp
+    nil
+  end
+end

data/lib/tiramisu/util/refute_throw.rb

@@ -0,0 +1,34 @@
+module Tiramisu
+
+  def refute_thrown_as_expected object, expected_symbol, block = nil
+    f = refute_thrown(object, expected_symbol)
+    return f if f
+
+    if expected_symbol
+      f = refute_expected_symbol_thrown(object, expected_symbol)
+      return f if f
+    end
+    nil
+  end
+
+  def refute_thrown object, should_throw = false
+    if should_throw
+      return [
+        'Expected a symbol to be thrown at %s' % object[:caller]
+      ] unless object[:thrown]
+    else
+      return [
+        'Not expected a symbol to be thrown at %s' % object[:caller]
+      ] if object[:thrown]
+    end
+    nil
+  end
+
+  def refute_expected_symbol_thrown object, expected_symbol
+    return [
+      'Not expected :%s to be thrown' % expected_symbol,
+      'at %s' % object[:caller]
+    ] if expected_symbol == object[:thrown]
+    nil
+  end
+end

data/test/assert_test.rb

@@ -0,0 +1,98 @@
+describe :assert do
+
+  it 'pass ==' do
+    x = mock(:==, :x)
+    x == :x
+    x.verify
+  end
+
+  it 'pass ===' do
+    x = mock(:===, :x)
+    x === :x
+    x.verify
+  end
+
+  it 'pass !=' do
+    x = mock(:!=, :x)
+    x != :x
+    x.verify
+  end
+
+  it 'pass >' do
+    x = mock(:>, :x)
+    x > :x
+    x.verify
+  end
+
+  it 'pass >=' do
+    x = mock(:>=, :x)
+    x >= :x
+    x.verify
+  end
+
+  it 'pass <' do
+    x = mock(:<, :x)
+    x < :x
+    x.verify
+  end
+
+  it 'pass <=' do
+    x = mock(:<=, :x)
+    x <= :x
+    x.verify
+  end
+
+  it 'pass eql?' do
+    x = mock(:eql?, :x)
+    x.eql? :x
+    x.verify
+  end
+
+  it 'pass equal?' do
+    x = mock(:equal?, :x)
+    x.equal? :x
+    x.verify
+  end
+
+  it 'pass =~' do
+    x = mock(:=~, :x)
+    x =~ :x
+    x.verify
+  end
+
+  it 'pass match' do
+    x = mock(:match, :x)
+    x.match :x
+    x.verify
+  end
+
+  it 'pass any?' do
+    m = mock(:any?)
+    m.any?
+    m.verify
+  end
+
+  it 'pass all?' do
+    x = mock(:all?, :x)
+    x.all? :x
+    x.verify
+  end
+
+  it 'pass start_with?' do
+    x = mock(:start_with?, :x)
+    x.start_with? :x
+    x.verify
+  end
+
+  it 'pass end_with?' do
+    x = mock(:end_with?, :x)
+    x.end_with? :x
+    x.verify
+  end
+
+  it 'pass respond_to?' do
+    x = mock(:respond_to?, :__id__, true)
+    x.respond_to? :__id__, true
+    x.verify
+  end
+end

data/test/context_inheritance_test.rb

@@ -0,0 +1,65 @@
+describe :context_inheritance_test do
+
+  it 'inherits from parent spec' do
+    x = nil
+    spec rand do
+      define_method(:set_x) {x = true}
+      context rand do
+        allocate.send(:set_x)
+      end
+    end
+    assert_equal true, x
+  end
+
+  it 'inherits from parent context' do
+    x = nil
+    spec rand do
+      context rand do
+        define_method(:set_x) {x = true}
+        context rand do
+          allocate.send(:set_x)
+        end
+      end
+    end
+    assert_equal true, x
+  end
+
+  it 'inherits from parent spec through parent context' do
+    x = nil
+    spec rand do
+      define_method(:set_x) {x = true}
+      context rand do
+        context rand do
+          allocate.send(:set_x)
+        end
+      end
+    end
+    assert_equal true, x
+  end
+
+  it 'does not inherit tests' do
+    spec_tests, context_tests = nil
+    spec rand do
+      test(:x) {}
+      context rand do
+        context_tests = tests.size
+      end
+      spec_tests = tests.size
+    end
+    assert_equal 1, spec_tests
+    assert_equal 0, context_tests
+  end
+
+  it 'does not inherit hooks' do
+    spec_hooks, context_hooks = nil
+    spec rand do
+      before {}
+      context rand do
+        context_hooks = hooks[:before].size
+      end
+      spec_hooks = hooks[:before].size
+    end
+    assert_equal 1, spec_hooks
+    assert_equal 0, context_hooks
+  end
+end

data/test/hooks_test.rb

@@ -0,0 +1,36 @@
+describe :hooks do
+  it 'calls wildcard hooks' do
+    called = 0
+    spec rand do
+      before {called += 1}
+      test(:a) {}
+      test(:b) {}
+      run(:a)
+      run(:b)
+    end
+    assert_equal 2, called
+  end
+
+  it 'calls named hooks' do
+    called = 0
+    spec rand do
+      after(:b) {called += 1}
+      test(:a) {}
+      test(:b) {}
+      run(:a)
+      run(:b)
+    end
+    assert_equal 1, called
+  end
+
+  it 'prefers named hooks over wildcard ones' do
+    called = nil
+    spec rand do
+      around(:a) {called = :named}
+      around {called = :wildcard}
+      test(:a) {}
+      run(:a)
+    end
+    assert_equal :named, called
+  end
+end