tokyo 0.0.5

data/lib/tokyo/util/refute_throw.rb

@@ -0,0 +1,34 @@
+module Tokyo
+
+  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/lib/tokyo/util.rb

@@ -0,0 +1,91 @@
+module Tokyo
+
+  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 find_files pattern_or_files
+    return pattern_or_files if pattern_or_files.is_a?(Array)
+    Dir[pwd(pattern_or_files)]
+  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 'tokyo/util/assert_raise'
+require 'tokyo/util/refute_raise'
+require 'tokyo/util/assert_throw'
+require 'tokyo/util/refute_throw'

data/lib/tokyo.rb

@@ -0,0 +1,121 @@
+require 'tty-progressbar'
+require 'tty-screen'
+require 'pastel'
+require 'json'
+
+module Tokyo
+  extend self
+
+  DEFAULT_PATTERN = '{spec,test}/**/{*_spec.rb,*_test.rb}'.freeze
+  GLOBAL_SETUPS = []
+
+  GenericFailure = Struct.new(:reason, :caller)
+  AssertionFailure = Struct.new(:object, :arguments, :caller)
+
+  Skip = Struct.new(:reason, :caller)
+
+  INDENT = '  '.freeze
+  PASTEL = Pastel.new
+  %w[
+    red
+    bright_red
+    green
+    blue
+    cyan
+    magenta
+    bold
+    underline
+  ].each {|m| define_method(m) {|*a| PASTEL.__send__(m, *a)}}
+
+  def units
+    @units ||= []
+  end
+
+  def assertions
+    @assertions ||= {}
+  end
+
+  def total_assertions
+    @total_assertions ||= []
+  end
+
+  def skips
+    @skips ||= []
+  end
+
+  def define_spec label, block
+    define_unit_class(:spec, label, block, [].freeze)
+  end
+
+  def define_and_register_a_spec label, block
+    units << define_spec(label, block)
+  end
+
+  def define_context label, block, parent
+    define_unit_class(:context, label, block, [*parent.__ancestors__, parent].freeze)
+  end
+
+  def define_and_register_a_context label, block, parent
+    units << define_context(label, block, parent)
+  end
+
+  # define a class that will hold contexts and tests
+  #
+  # @param  [String, Symbol] type
+  # @param  [String, Symbol] label
+  # @param  [Proc] block
+  # @param  [Array] ancestors
+  # @return [Unit]
+  #
+  def define_unit_class type, label, block, ancestors
+    identity = identity_string(type, label, block).freeze
+    Class.new ancestors.last || Unit do
+      define_singleton_method(:__ancestors__) {ancestors}
+      define_singleton_method(:__identity__) {identity}
+      Tokyo::GLOBAL_SETUPS.each {|b| class_exec(&b)}
+      # execute given block only after global setups executed and all utility methods defined
+      result = catch(:__tokyo_skip__) {class_exec(&block)}
+      Tokyo.skips << result if result.is_a?(Skip)
+    end
+  end
+
+  # define a module that when included will execute the given block on base
+  #
+  # @param  [Proc] block
+  # @return [Module]
+  #
+  def define_unit_module block
+    block || raise(ArgumentError, 'missing block')
+    Module.new do
+      # any spec/context that will include this module will "inherit" it's logic
+      #
+      # @example
+      #   EnumeratorSpec = spec 'Enumerator tests' do
+      #     # some tests here
+      #   end
+      #
+      #   spec Array do
+      #     include EnumeratorSpec
+      #   end
+      #
+      #   spec Hash do
+      #     include EnumeratorSpec
+      #   end
+      #
+      define_singleton_method(:included) {|b| b.class_exec(&block)}
+    end
+  end
+
+  # stop any code and report a failure
+  def fail reason, caller
+    throw(:__tokyo_status__, GenericFailure.new(Array(reason), caller))
+  end
+end
+
+require 'tokyo/core_ext'
+require 'tokyo/pretty_print'
+require 'tokyo/expectations'
+require 'tokyo/util'
+require 'tokyo/unit'
+require 'tokyo/assert'
+require 'tokyo/run'

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,52 @@
+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
+end

data/test/hooks_test.rb

@@ -0,0 +1,35 @@
+describe :hooks do
+
+  it 'calls before and after hooks' do
+    called = 0
+    spec rand do
+      before {called += 1}
+      after {called += 1}
+      test(:x) {}
+      run(:x)
+    end
+    assert_equal 2, called
+  end
+
+  it 'calls around hooks' do
+    called = false
+    spec rand do
+      around {|test| test.call}
+      test(:x) {called = true}
+      run(:x)
+    end
+    assert_equal true, called
+  end
+
+  it 'inherits hooks' do
+    spec_hooks, context_hooks = nil
+    spec rand do
+      before {}
+      context rand do
+        context_hooks = hooks
+      end
+      spec_hooks = hooks
+    end
+    assert_equal context_hooks, spec_hooks
+  end
+end

data/test/raise_test.rb

@@ -0,0 +1,66 @@
+describe :raise do
+
+  it 'should pass if any exception raised' do
+    this = self
+    spec rand do
+      test(:test) {assert {x}.raise}
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail if nothing raised' do
+    this = self
+    spec rand do
+      test(:test) {assert {}.raise}
+      this.assert_equal Tokyo::GenericFailure, run(:test).class
+    end
+  end
+
+  it 'should pass if type matching' do
+    this = self
+    spec rand do
+      test(:test) {assert {x}.raise(NameError)}
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail if wrong exception raised' do
+    this = self
+    spec rand do
+      test(:test) {assert {}.raise(ArgumentError)}
+      this.assert_equal Tokyo::GenericFailure, run(:test).class
+    end
+  end
+
+  it 'should pass if both type and message matches' do
+    this = self
+    spec rand do
+      test(:test) {assert {x}.raise NameError, /undefined local variable or method/}
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail if message does not match' do
+    this = self
+    spec rand do
+      test(:test) {assert {x}.raise(NameError, /blah/)}
+      this.assert_equal Tokyo::GenericFailure, run(:test).class
+    end
+  end
+
+  it 'should pass if given block validates the raised error' do
+    this = self
+    spec rand do
+      test(:test) {assert {x}.raise {|e| e.class == NameError && e.message =~ /undefined local variable or method/}}
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail if given block invalidates raised error' do
+    this = self
+    spec rand do
+      test(:test) {assert {x}.raise {false}}
+      this.assert_equal Tokyo::GenericFailure, run(:test).class
+    end
+  end
+end

data/test/receive_and_raise_test.rb

@@ -0,0 +1,83 @@
+describe :receive_and_raise do
+
+  it 'should pass when received message raises as expected' do
+    this = self
+    spec rand do
+      test :test do
+        expect(x = 'x').to_receive(:y).and_raise(NoMethodError)
+        x.y
+      end
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should pass when received message raises whatever error' do
+    this = self
+    spec rand do
+      test :test do
+        expect(x = 'x').to_receive(:y).and_raise
+        x.y
+      end
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when received message does not raise' do
+    this = self
+    spec rand do
+      test :test do
+        expect(x = 'x').to_receive(:to_s).and_raise
+        x.to_s
+      end
+      this.assert_match /Expected a exception to be raised/, run(:test).reason*' '
+    end
+  end
+
+  it 'should fail when received message raises a unexpected error type' do
+    this = self
+    spec rand do
+      test :test do
+        expect(x = 'x').to_receive(:y).and_raise(NameError)
+        x.y
+      end
+      this.assert_match /Expected a NameError to be raised/, run(:test).reason*' '
+    end
+  end
+
+  it 'should fail when error raised by received message is of expected type but error message does not match' do
+    this = self
+    spec rand do
+      test :test do
+        expect(x = 'x').to_receive(:y).and_raise(NoMethodError, /blah/)
+        x.y
+      end
+      this.assert_match /to match "blah"/, run(:test).reason*' '
+    end
+  end
+
+  it 'should pass if received message raises a error that match by type and message' do
+    this = self
+    spec rand do
+      test :test do
+        expect(x = 'x').to_receive(:y).and_raise(NoMethodError, /undefined method `y' for "x":String/)
+        x.y
+      end
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should pass if error raised by received message are validated by block' do
+    this, t, m = self, nil, nil
+    spec rand do
+      test :test do
+        expect(x = 'x').to_receive(:y).and_raise {|e|
+          t, m = e.class, e.message
+        }
+        x.y
+      end
+      run(:test)
+      this.assert_equal NoMethodError, t
+      this.assert_match /undefined method .y. for "x":String/, m
+    end
+  end
+end

data/test/receive_and_return_test.rb

@@ -0,0 +1,46 @@
+describe :receive_and_return do
+
+  it 'should pass when expected message returns expected value' do
+    this = self
+    spec rand do
+      test :test do
+        expect(x = 'x').to_receive(:+).with('y').and_return('xy')
+        x + 'y'
+      end
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when expected message returns wrong value' do
+    this = self
+    spec rand do
+      test :test do
+        expect(x = 'x').to_receive(:to_s).and_return(:y)
+        x.to_s
+      end
+      this.assert_match /Looks like :to_s message never returned expected value/, run(:test).reason*' '
+    end
+  end
+
+  it 'should pass when block validates returned value' do
+    this = self
+    spec rand do
+      test :test do
+        expect(x = 'x').to_receive(:+).with('y').and_return {|v| v == 'xy'}
+        x + 'y'
+      end
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when block does not validate returned value' do
+    this = self
+    spec rand do
+      test :test do
+        expect(x = 'x').to_receive(:+).with('y').and_return {false}
+        x + 'y'
+      end
+      this.assert_match /Looks like :\+ message never returned expected value/, run(:test).reason*' '
+    end
+  end
+end

data/test/receive_and_throw_test.rb

@@ -0,0 +1,74 @@
+describe :receive_and_throw do
+
+  it 'should pass when received message throws whatever' do
+    this = self
+    spec rand do
+      test :test do
+        x = Class.new {define_singleton_method(:y) {throw :z}}
+        expect(x).to_receive(:y).and_throw
+        x.y
+      end
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should pass when received message throws expected symbol' do
+    this = self
+    spec rand do
+      test :test do
+        x = Class.new {define_singleton_method(:y) {throw :z}}
+        expect(x).to_receive(:y).and_throw(:z)
+        x.y
+      end
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when received message throws nothing' do
+    this = self
+    spec rand do
+      test :test do
+        x = Class.new {define_singleton_method(:y) {}}
+        expect(x).to_receive(:y).and_throw
+        x.y
+      end
+      this.assert_match /Expected a symbol to be thrown/, run(:test).reason*' '
+    end
+  end
+
+  it 'should fail when received message throws wrong symbol' do
+    this = self
+    spec rand do
+      test :test do
+        x = Class.new {define_singleton_method(:y) {throw :z}}
+        expect(x).to_receive(:y).and_throw(:a)
+        x.y
+      end
+      this.assert_match /Expected :a to be thrown/, run(:test).reason*' '
+    end
+  end
+
+  it 'should pass when given block validates thrown symbol' do
+    this = self
+    spec rand do
+      test :test do
+        x = Class.new {define_singleton_method(:y) {throw :z}}
+        expect(x).to_receive(:y).and_throw {|s| s == :z}
+        x.y
+      end
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when block does not validate thrown symbol' do
+    this = self
+    spec rand do
+      test :test do
+        x = Class.new {define_singleton_method(:y) {throw :z}}
+        expect(x).to_receive(:y).and_throw {false}
+        x.y
+      end
+      this.assert_match /Looks like wrong or no symbol thrown/, run(:test).reason*' '
+    end
+  end
+end