tokyo 0.0.5

data/lib/tokyo/expectations/return.rb

@@ -0,0 +1,32 @@
+module Tokyo
+  class Expectation
+
+    # ensure received message returns expected value
+    #
+    # @note if block given it will have precedence over arguments
+    #
+    # @example
+    #   n = mock(1)
+    #   expect(n).to_receive(:+).with(1).and_return(2)
+    #
+    def and_return value = nil, &block
+      @return = block || value
+    end
+
+    private
+    def assert_message_returned_correct_value
+      return unless @return
+      if @return.is_a?(Proc)
+        received_messages.find {|log| @return.call(log[:returned])} || Tokyo.fail([
+          'Looks like :%s message never returned expected value' % expected_message,
+          'See validation block'
+        ], @caller)
+      else
+        received_messages.find {|log| log[:returned] == @return} || Tokyo.fail([
+          'Looks like :%s message never returned expected value:' % expected_message,
+          Array(@return).map {|x| Tokyo.pp(x)}.join(', ')
+        ], @caller)
+      end
+    end
+  end
+end

data/lib/tokyo/expectations/throw.rb

@@ -0,0 +1,24 @@
+module Tokyo
+  class Expectation
+
+    # ensure received message throws as expected
+    #
+    # @note if block given it will have precedence over arguments
+    #
+    # @example
+    #   x = mock(X.new)
+    #   expect(x).to_receive(:y).and_throw(:z)
+    #
+    def and_throw symbol = nil, &block
+      @throw = [symbol, block]
+    end
+
+    def assert_message_thrown_as_expected
+      return unless @throw
+      received_messages.each do |log|
+        next unless f = Tokyo.assert_thrown_as_expected(log, *@throw)
+        Tokyo.fail(f, log[:caller])
+      end
+    end
+  end
+end

data/lib/tokyo/expectations/with.rb

@@ -0,0 +1,36 @@
+module Tokyo
+  class Expectation
+
+    # ensure expected message received with correct arguments
+    #
+    # @note if block given it will have precedence over arguments
+    #
+    # @example
+    #   test :some_test do
+    #     some_object = mock(SomeObject.new)
+    #     expect(some_object).to_receive(:some_method).with(:some, :args)
+    #     # call `some_object.some_method(:some, :args)` for test to pass
+    #   end
+    #
+    def with *args, &block
+      @with = block || args
+      self
+    end
+
+    private
+    def assert_message_received_with_correct_arguments
+      return unless @with
+      if @with.is_a?(Proc)
+        received_messages.find {|log| @with.call(log[:arguments])} || Tokyo.fail([
+          'Looks like :%s message never was called with expected arguments' % expected_message,
+          'See validation block'
+        ], @caller)
+      else
+        received_messages.find {|log| log[:arguments] == @with} || Tokyo.fail([
+          'Looks like :%s message never was called with expected arguments:' % expected_message,
+          Array(@with).map {|x| Tokyo.pp(x)}.join(', ')
+        ], @caller)
+      end
+    end
+  end
+end

data/lib/tokyo/expectations.rb

@@ -0,0 +1,103 @@
+module Tokyo
+  class Expectation
+
+    def self.restore_object_status obj
+      return unless obj.instance_variable_get(:@__tokyo__original_methods__)
+
+      obj.instance_variable_get(:@__tokyo__original_methods__).each_pair do |n,m|
+        obj.define_singleton_method(n, &m)
+      end
+
+      obj.instance_variable_set(:@__tokyo__original_methods__, {})
+      obj.instance_variable_set(:@__tokyo__received_messages__, {})
+    end
+
+    attr_reader :expected_message, :received_messages
+
+    def initialize object, expected_message, assert, caller
+      @object = object
+      @expected_message = expected_message.to_sym
+      @assert = assert
+      @caller = caller
+      proxify(@object, @expected_message)
+    end
+
+    def validate
+      @received_messages = @object.__tokyo__received_messages__[expected_message] || []
+      return refute_message_received unless @assert
+      assert_message_received
+      assert_message_received_with_correct_arguments
+      assert_message_returned_correct_value
+      assert_message_raised_as_expected
+      assert_message_thrown_as_expected
+    end
+
+    private
+    def proxify object, method
+      mount_original_methods_depot(object)
+      mount_received_messages_depot(object)
+      store_original_method(object, method)
+
+      object.define_singleton_method method do |*a,&b|
+        log = {arguments: a, block: b, caller: Tokyo.relative_location(caller[0])}
+        (__tokyo__received_messages__[method] ||= []).push(log)
+
+        if __tokyo__original_methods__[method]
+          return begin
+            log[:returned] = __tokyo__original_methods__[method].call(*a, &b)
+          rescue UncaughtThrowError => e
+            log[:thrown] = Tokyo.extract_thrown_symbol(e)
+          rescue Exception => e
+            log[:raised] = e
+          end
+        end
+
+        if respond_to?(:method_missing)
+          return begin
+            log[:returned] = __send__(:method_missing, method, *a, &b)
+          rescue UncaughtThrowError => e
+            log[:thrown] = Tokyo.extract_thrown_symbol(e)
+          rescue Exception => e
+            log[:raised] = e
+          end
+        end
+
+        log[:raised] = NoMethodError.new("undefined method `%s' for %s:%s" % [method, self.inspect, self.class])
+      end
+    end
+
+    def mount_original_methods_depot object
+      return if object.respond_to?(:__tokyo__original_methods__)
+      def object.__tokyo__original_methods__; @__tokyo__original_methods__ ||= {} end
+    end
+
+    def mount_received_messages_depot object
+      return if object.respond_to?(:__tokyo__received_messages__)
+      def object.__tokyo__received_messages__; @__tokyo__received_messages__ ||= {} end
+    end
+
+    def store_original_method object, method
+      return unless object.respond_to?(method)
+      object.__tokyo__original_methods__[method] ||= object.method(method)
+    end
+
+    def assert_message_received
+      Tokyo.fail('Expected %s to receive %s message' % [
+        Tokyo.pp(@object),
+        Tokyo.pp(expected_message)
+      ], @caller) if received_messages.empty?
+    end
+
+    def refute_message_received
+      Tokyo.fail('Not Expected %s to receive %s message' % [
+        Tokyo.pp(@object),
+        Tokyo.pp(expected_message)
+      ], @caller) if received_messages.any?
+    end
+  end
+end
+
+require 'tokyo/expectations/with'
+require 'tokyo/expectations/return'
+require 'tokyo/expectations/raise'
+require 'tokyo/expectations/throw'

data/lib/tokyo/pretty_print.rb

@@ -0,0 +1,55 @@
+require 'pp'
+require 'coderay'
+
+# Stolen from [Pry](https://github.com/pry/pry)
+#
+# Copyright (c) 2013 John Mair (banisterfiend)
+# Copyright (c) 2015 Slee Woo (sleewoo)
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# 'Software'), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module Tokyo
+  def pp obj
+    out = ''
+    q = Tokyo::PrettyPrint.new(out)
+    q.guard_inspect_key { q.pp(obj) }
+    q.flush
+    out
+  end
+
+  class PrettyPrint < ::PP
+    OBJECT_LITERAL_FORMAT = "\e[32m%s\e[0m".freeze
+
+    def text str, width = str.length
+      if str.include?("\e[")
+        super "%s\e[0m" % str, width
+      elsif str.start_with?('#<') || str == '=' || str == '>'
+        super highlight_object_literal(str), width
+      else
+        super CodeRay.scan(str, :ruby).term, width
+      end
+    end
+
+    private
+    def highlight_object_literal object_literal
+      OBJECT_LITERAL_FORMAT % object_literal
+    end
+  end
+end

data/lib/tokyo/run.rb

@@ -0,0 +1,126 @@
+module Tokyo
+
+  def progress
+    @progress ||= TTY::ProgressBar.new ':current of :total [:bar]' do |cfg|
+      cfg.total = units.map {|u| u.tests.size}.reduce(:+) || 0
+      cfg.width = TTY::Screen.width
+      cfg.complete = '.'
+    end
+  end
+
+  def run pattern_or_files = DEFAULT_PATTERN
+    specs = 0
+    tests = 0
+    assertions = 0
+    find_files(pattern_or_files).shuffle.each do |file|
+      r, w = IO.pipe
+      pid = Kernel.fork do
+        r.close
+        load_file(file)
+        progress.log ''
+        progress.log cyan(relative_location(file))
+        units.shuffle.each do |unit|
+          # exceptions raised inside unit#__run__ will be treated as failures and pretty printed.
+          # any other exceptions will be treated as implementation errors and ugly printed.
+          unit.tests.keys.shuffle.each do |test|
+            status = unit.run(test)
+            if status.is_a?(Skip)
+              w.puts({skip: true, reason: status.reason, caller: status.caller}.to_json)
+            else
+              unless status == :__tokyo_passed__
+                render_failure(unit, unit.tests[test], status)
+                Kernel.exit(1)
+              end
+            end
+            progress.advance
+          end
+        end
+        w.puts(totals.to_json)
+      end
+      _, status = Process.waitpid2(pid)
+      Kernel.exit(1) unless status.success?
+      w.close
+      while line = r.gets
+        line = JSON.parse(line)
+        if line['skip']
+          skips << line
+        elsif line['totals']
+          specs += line['specs']
+          tests += line['tests']
+          assertions += line['assertions']
+        else
+          raise('Incomprehensible message received: %s' % line)
+        end
+      end
+    end
+    render_skips
+    render_totals(specs, tests, assertions)
+  end
+
+  def totals
+    {
+      totals: true,
+      specs: units.select {|u| u.__ancestors__.empty?}.size,
+      tests: units.map {|u| u.tests.size}.reduce(:+),
+      assertions: total_assertions.size
+    }
+  end
+
+  def render_totals specs, tests, assertions
+    puts
+    puts
+    puts bold.cyan('           Specs: %i' % specs)
+    puts bold.cyan('           Tests: %i' % tests)
+    puts bold.cyan('      Assertions: %i' % assertions)
+    puts
+  end
+
+  def render_failure unit, test_uuid, failure
+    indent = ''
+    [*unit.__ancestors__, unit].each do |u|
+      progress.log indent + u.__identity__
+      indent << INDENT
+    end
+    progress.log indent + test_uuid
+    indent << INDENT
+    case failure
+    when Exception
+      render_exception(indent, failure)
+    when GenericFailure, AssertionFailure
+      render_caller(indent, failure.caller)
+      __send__('render_%s' % failure.class.name.split('::').last, indent, failure)
+    else
+      progress.log(indent + failure.inspect)
+    end
+    progress.log ''
+  end
+
+  def render_exception indent, failure
+    progress.log indent + underline.bright_red([failure.class, failure.message]*': ')
+    pretty_backtrace(failure).each {|l| progress.log(indent + l)}
+  end
+
+  def render_GenericFailure indent, failure
+    Array(failure.reason).each {|l| progress.log(indent + l.to_s)}
+  end
+
+  def render_AssertionFailure indent, failure
+    progress.log indent + cyan('a: ') + pp(failure.object)
+    progress.log indent + cyan('b: ') + failure.arguments.map {|a| pp(a)}.join(', ')
+  end
+
+  def render_caller indent, caller
+    return unless caller
+    progress.log indent + underline.bright_red(readline(caller))
+  end
+
+  def render_skips
+    return if skips.empty?
+    puts
+    puts bold.magenta('Skips:')
+    skips.each do |skip|
+      puts '  %s (%s)' % [blue(skip['reason'] || 'skip'), relative_location(skip['caller'])]
+    end
+    puts
+  end
+end

data/lib/tokyo/unit.rb

@@ -0,0 +1,185 @@
+module Tokyo
+  class Unit
+
+    # @example
+    #   assert(x) == y
+    #   assert(x).include?(y)
+    #   assert(x).nil?
+    #   refute(a).include?(b)
+    #   fail_if(a).include?(b)
+    [
+      :assert,
+      :refute
+    ].each do |meth|
+      define_method meth do |obj = nil, &block|
+        __objects__[obj = block ? Tokyo.call_block(block) : {returned: obj}.freeze] = true
+        __assertions__.push(Tokyo::Assert.new(obj, meth, caller[0])).last
+      end
+    end
+    alias expect assert
+    alias fail_if refute
+
+    # stop executing current test and mark it as skipped
+    #
+    # @example
+    #   test :something do
+    #     skip "recheck this after fixing X"
+    #     assert(x) == y # this wont run
+    #   end
+    #
+    def skip reason = nil
+      throw(:__tokyo_status__, Tokyo::Skip.new(reason, caller[0]))
+    end
+
+    def __run__ test, before, around, after
+      __send__(before) if before
+      if around
+        __send__(around, proc {__send__(test)})
+      else
+        __send__(test)
+      end
+      __send__(after) if after
+      __assertions__.each(&:__validate_expectations__)
+      __objects__.each_key {|o| Tokyo::Expectation.restore_object_status(o[:returned])}
+      :__tokyo_passed__
+    rescue Exception => e
+      throw(:__tokyo_status__, e)
+    end
+
+    private
+    def __objects__
+      @__objects__ ||= {}
+    end
+
+    def __assertions__
+      @__assertions__ ||= []
+    end
+  end
+
+  class << Unit
+
+    def inherited base
+      base.instance_variable_set(:@__tokyo_hooks__, Marshal.load(Marshal.dump(hooks)))
+    end
+
+    def spec
+      raise(NotImplementedError, 'Nested specs not supported. Please use a context instead')
+    end
+
+    # define a context inside current spec/context.
+    #
+    # @param label
+    # @param &block
+    #
+    def context label, &block
+      return unless block
+      Tokyo.define_and_register_a_context(label, block, self)
+    end
+
+    # define a test
+    #
+    # @param label
+    # @param &block
+    #
+    def test label, &block
+      return unless block
+      tests[label] = Tokyo.identity_string(:test, label, block)
+      define_method(tests[label], &block)
+    end
+    alias it test
+    alias should test
+
+    def tests
+      @__tokyo_tests__ ||= {}
+    end
+
+    # run some code before/around/after tests
+    #
+    # @example
+    #   spec User do
+    #     before do
+    #       @users = ...
+    #     end
+    #
+    #     test :login do
+    #       # @users available here
+    #     end
+    #   end
+    #
+    # @example
+    #   spec User do
+    #     around |&test|
+    #       SomeApi.with_auth do
+    #         test.call # run the test
+    #       end
+    #     end
+    #
+    #     test :authorize do
+    #       # will run inside `with_auth` block
+    #     end
+    #   end
+    #
+    # @note hooks are inherited from parent spec or context
+    #
+    # @example
+    #   spec Math do
+    #     before { @n = rand }
+    #
+    #     context :PI do
+    #       test :some_test do
+    #         # @n available here
+    #       end
+    #     end
+    #   end
+    #
+    # @note defined hooks will override inherited ones
+    #
+    # @example
+    #   spec Math do
+    #     before { @n = 1 }
+    #
+    #     context :x do
+    #       before { @n = 0 }
+    #       test :some_test do
+    #         # @n is zero here
+    #       end
+    #     end
+    #   end
+    #
+    [
+      :before,
+      :around,
+      :after
+    ].each do |hook|
+      define_method hook do |&block|
+        block || raise(ArgumentError, 'block missing')
+        hooks[hook] = :"__tokyo__#{hook}_hook__"
+        define_method(hooks[hook], &block)
+      end
+    end
+
+    def hooks
+      @__tokyo_hooks__ ||= {}
+    end
+
+    # skipping a whole spec/context
+    #
+    # @example
+    #   spec Array do
+    #     skip
+    #
+    #     # code here wont be executed
+    #   end
+    #
+    def skip reason = nil
+      throw(:__tokyo_skip__, Tokyo::Skip.new(reason, caller[0]))
+    end
+
+    def run test
+      tests[test] || raise(StandardError, 'Undefined test %s at "%s"' % [test.inspect, __identity__])
+      catch :__tokyo_status__ do
+        allocate.__run__(tests[test], hooks[:before], hooks[:around], hooks[:after])
+      end
+    end
+  end
+end

data/lib/tokyo/util/assert_raise.rb

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

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

@@ -0,0 +1,48 @@
+module Tokyo
+
+  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