kintama 0.1.9 → 0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '0585d375e075683687b7a47da3323ace4468f9a9f61c4fdb2c8931144a879d55'
+  data.tar.gz: 63325f6c21c46bec7432996421fe43ac54316a5b96c12d0c89851dd2f9fd88ea
+SHA512:
+  metadata.gz: d90b1a3eb60ff446e2ebeea8e9e251384750db13dde88986aa86164da6595bbbac6ccff9dec4ad44f36d915a86e84bce64dd9fc0075ee478462236b39a828396
+  data.tar.gz: 317f355a6141242af6c6d5efb388b8bfa8fbc9ab14a5d56f02e1413485470901b970ae4565645adf0d7c8604bff956edc63163d6e68e78c4c33cc6c090e96aea

data/README.md

@@ -30,7 +30,7 @@ Probably the closest thing I've seen is [baretest][]. If you look around the cod
 
 Another alternative test framework is [riot][], which claims to be fast, but also appears to constrain the way that tests are written by avoiding instance variables in setups, for example.
 
-[Testy][] is interesting - it looks like its output is YAML!. [Tryouts][] is thinking outside the box, using comment examples.
+[Testy][] is interesting - it looks like its output is YAML! [Tryouts][] is thinking outside the box, using comment examples.
 
 [Zebra][] addresses the apparent duplication of the test name and the test body, but does it by introducing an [RSpec][]-esque method on every object. Wild. Also, it's an extension of [Test::Unit][], so that's strike two for me, personally.
 
@@ -66,7 +66,7 @@ These will all be very familiar to most people who are already users of [shoulda
       end
     end
 
-Simple, right? Note that we don't need an outer subclass of `Test::Unit::TestCase`; it's nice to lose that noise, but otherwise so far so same-old-same-old. That's kind-of the point. Anyway, here's what you get when you run this:
+Simple, right? Note that we don't need an outer subclass of `Minitest::Test` or `Test::Unit::TestCase`; it's nice to lose that noise, but otherwise so far so same-old-same-old. That's kind-of the point. Anyway, here's what you get when you run this:
 
     A thing
       should act like a thing: F

data/lib/kintama.rb

@@ -11,13 +11,17 @@ module Kintama
   autoload :Assertions, 'kintama/assertions'
 
   class << self
+    def no_conflict?
+      ENV["KINTAMA_NO_CONFLICT"]
+    end
+
     def reset
       @default_context = Class.new(Runnable)
       @default_context.send(:include, Kintama::Context)
     end
 
     def default_context
-      reset unless @default_context
+      reset unless instance_variable_defined?(:@default_context) && @default_context
       @default_context
     end
 
@@ -43,6 +47,16 @@ module Kintama
       default_context.teardown(&block)
     end
 
+    def on_start(&block)
+      default_context.on_start(&block)
+    end
+    alias_method :before_all, :on_start
+
+    def on_finish(&block)
+      default_context.on_finish(&block)
+    end
+    alias_method :after_all, :on_finish
+
     # Makes behaviour available within tests:
     #
     #   module SomeModule
@@ -63,12 +77,12 @@ module Kintama
     end
 
     def options
-      unless @options
-        @options = OpenStruct.new(
+      @options ||= begin
+        options = OpenStruct.new(
           :reporter => Kintama::Reporter.default,
           :runner => Kintama::Runner.default
         )
-        opts = OptionParser.new do |opts|
+        cmd_options = OptionParser.new do |opts|
           opts.banner = "Usage: ruby <test_file> [options]"
 
           opts.separator ""
@@ -76,9 +90,7 @@ module Kintama
 
           opts.on("-r", "--reporter NAME",
                   "Use the given reporter (inline or verbose)") do |reporter|
-                  puts "reporter!"
             options.reporter = Kintama::Reporter.called(reporter)
-            p options.reporter
           end
           opts.on("-l", "--line LINE",
                   "Run the test or context on the given line") do |line|
@@ -89,16 +101,16 @@ module Kintama
             exit
           end
         end
-        opts.parse!(ARGV)
+        cmd_options.parse!(ARGV)
+        options
       end
-      @options
     end
 
     # Adds the hook to automatically run all known tests using #run when
     # ruby exits; this is most useful when running a test file from the command
     # line or from within an editor
     def add_exit_hook
-      return if @__added_exit_hook
+      return if instance_variable_defined?(:@__added_exit_hook)
       at_exit { exit(options.runner.with(Kintama.default_context).run(options.reporter) ? 0 : 1) }
       @__added_exit_hook = true
     end
@@ -127,9 +139,11 @@ module Kintama
   end
 end
 
-[:context, :given, :describe, :testcase].each do |method|
-  unless self.respond_to?(method)
-    eval %|def #{method}(*args, &block); Kintama.#{method}(*args, &block); end|
+unless Kintama.no_conflict?
+  [:context, :given, :describe, :testcase].each do |method|
+    unless self.respond_to?(method)
+      eval %|def #{method}(*args, &block); Kintama.#{method}(*args, &block); end|
+    end
   end
 end
 

data/lib/kintama/assertions.rb

@@ -1,4 +1,5 @@
 require "set"
+require "stringio"
 
 module Kintama
   module Assertions
@@ -30,10 +31,18 @@ module Kintama
       assert (string =~ regexp), message
     end
 
+    def assert_no_match(regexp, string, message="expected #{string.inspect} not to match #{regexp.inspect}")
+      assert !(string =~ regexp), message
+    end
+
     def assert_kind_of(klass, thing, message="should be a kind of #{klass}")
       assert thing.is_a?(klass), message
     end
 
+    def assert_same(expected, actual, message="Expected #{expected.inspect} (oid=#{expected.object_id}) to be the same as #{actual.inspect} (oid=#{actual.object_id})")
+      assert actual.equal?(expected), message
+    end
+
     def assert_same_elements(expected, object, message = "#{object.inspect} does not contain the same elements as #{expected.inspect}")
       assert Set.new(expected) == Set.new(object), message
     end
@@ -62,5 +71,35 @@ module Kintama
     ensure
       raise Kintama::TestFailure, message unless raised
     end
+
+    def assert_output(expected, message="Expected output to match #{expected.inspect}", &block)
+      output = capture_output(&block).read.strip
+      if expected.is_a?(Regexp)
+        assert_match expected, output, message
+      else
+        assert_equal expected, output, message
+      end
+    end
+
+    def assert_not_output(not_expected, message="Expected output not to match #{not_expected.inspect}", &block)
+      output = capture_output(&block).read.strip
+      if not_expected.is_a?(Regexp)
+        assert_no_match not_expected, output, message
+      else
+        assert_not_equal not_expected, output, message
+      end
+    end
+
+    private
+
+    def capture_output(&block)
+      out = StringIO.new
+      $stdout = out
+      yield
+      out.rewind
+      return out
+    ensure
+      $stdout = STDOUT
+    end
   end
-end
+end

data/lib/kintama/context.rb

@@ -1,9 +1,46 @@
 module Kintama
   module Context
-    def setup # noop
+    def setup
+      (setup_blocks + after_setup_blocks).each do |block|
+        instance_eval(&block)
+      end
+    end
+
+    def teardown
+      blocks = teardown_blocks
+      blocks.each do |block|
+        instance_eval(&block)
+      end
+    end
+
+    def setup_blocks
+      context = self.class
+      blocks = context.setup_blocks
+      while(context.superclass.respond_to?(:setup_blocks))
+        context = context.superclass
+        blocks.unshift(*context.setup_blocks)
+      end
+      blocks
+    end
+
+    def after_setup_blocks
+      context = self.class
+      blocks = context.after_setup_blocks
+      while(context.superclass.respond_to?(:after_setup_blocks))
+        context = context.superclass
+        blocks.unshift(*context.after_setup_blocks)
+      end
+      blocks
     end
 
-    def teardown # noop
+    def teardown_blocks
+      context = self.class
+      blocks = context.teardown_blocks
+      while(context.superclass.respond_to?(:teardown_blocks))
+        context = context.superclass
+        blocks.push(*context.teardown_blocks)
+      end
+      blocks
     end
 
     def self.included(base)
@@ -13,7 +50,7 @@ module Kintama
     module ClassMethods
 
       def find_definition_1_8
-        line = caller.find { |line| line =~ /^[^:]+:(\d+)$/ }
+        line = caller.find { |l| l =~ /^[^:]+:(\d+)$/ }
         if line
           parts = line.split(":")
           parts[1] = parts[1].to_i
@@ -21,22 +58,22 @@ module Kintama
         end
       end
 
-      def find_definition_1_9(&block)
+      def find_definition_yarv(&block)
         block.source_location if block
       end
 
       def find_definition_rbx(&block)
         if block
-          m = block.block.code
-          [m.file, m.first_line]
+          block_environment = block.block
+          [block_environment.file, block_environment.line]
         end
       end
 
       def find_definition(&block)
         if defined? RUBY_ENGINE
           case RUBY_ENGINE
-          when "ruby"
-            RUBY_VERSION =~ /^1.9/ ? find_definition_1_9(&block) : find_definition_1_8
+          when "ruby", "jruby"
+            Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('1.9') ? find_definition_yarv(&block) : find_definition_1_8
           when "rbx"
             find_definition_rbx(&block)
           end
@@ -67,6 +104,10 @@ module Kintama
         @setup_blocks ||= []
       end
 
+      def after_setup_blocks
+        @after_setup_blocks ||= []
+      end
+
       def teardown_blocks
         @teardown_blocks ||= []
       end
@@ -75,26 +116,17 @@ module Kintama
       # It will also be run for any subcontexts, before their own setup blocks
       def setup(&block)
         self.setup_blocks << block
+      end
 
-        # redefine setup for the current set of blocks
-        blocks = self.setup_blocks
-        define_method(:setup) do
-          super()
-          blocks.each { |b| instance_eval(&b) }
-        end
+      def after_setup(&block)
+        self.after_setup_blocks << block
       end
+      alias_method :action, :after_setup
 
       # Define the teardown for this context.
       # It will also be run for any subcontexts, after their own teardown blocks
       def teardown(&block)
         self.teardown_blocks << block
-
-        # redefine teardown for the current set of blocks
-        blocks = self.teardown_blocks
-        define_method(:teardown) do
-          blocks.each { |b| instance_eval(&b) }
-          super()
-        end
       end
 
       def on_start_blocks
@@ -115,11 +147,20 @@ module Kintama
       end
       alias_method :after_all, :on_finish
 
+      def let(name, &block)
+        define_method(name) do
+          memo = "@__#{name}"
+          if instance_variable_defined?(memo)
+            instance_variable_get(memo)
+          else
+            instance_variable_set(memo, instance_eval(&block))
+          end
+        end
+      end
+
       # Defines the subject of any matcher-based tests.
       def subject(&block)
-        define_method(:subject) do
-          @__subject ||= yield
-        end
+        let("subject", &block)
       end
 
       # Define a test to run in this context.
@@ -199,28 +240,6 @@ module Kintama
         subcontexts.find { |s| s.name == name } || tests.find { |t| t.name == name }
       end
 
-      def method_missing(name, *args, &block)
-        if self[de_methodize(name)]
-          self[de_methodize(name)]
-        else
-          begin
-            super
-          rescue NameError, NoMethodError => e
-            if parent
-              parent.send(name, *args, &block)
-            else
-              raise e
-            end
-          end
-        end
-      end
-
-      def respond_to?(name)
-        self[name] ||
-        super ||
-        (parent ? parent.respond_to?(name) : false)
-      end
-
       # Runs all tests in this context and any subcontexts.
       # Returns true if all tests passed; otherwise false
       def run(reporter=nil)
@@ -257,10 +276,6 @@ module Kintama
 
       private
 
-      def de_methodize(name)
-        name.to_s.gsub("_", " ")
-      end
-
       def ran_tests
         @ran_tests || []
       end

data/lib/kintama/mocha.rb

@@ -1,12 +1,34 @@
-require 'mocha/standalone'
-
-Kintama.include Mocha::API
-Kintama.teardown do
-  begin
-    mocha_verify
-  rescue Mocha::ExpectationError => e
-    raise e
-  ensure
-    mocha_teardown
+require 'kintama'
+require 'mocha/api'
+
+module Kintama::Mocha
+  module Expect
+    def expect(name, &block)
+      context do
+        setup(&block)
+        test("expect " + name) {}
+      end
+    end
+  end
+
+  def self.setup
+    Kintama.include Mocha::API
+    Kintama.include Mocha::Hooks
+    Kintama.extend(Kintama::Mocha::Expect)
+
+    Kintama.setup do
+      mocha_setup
+    end
+    Kintama.teardown do
+      begin
+        mocha_verify
+      rescue Mocha::ExpectationError => e
+        raise e
+      ensure
+        mocha_teardown
+      end
+    end
   end
 end
+
+Kintama::Mocha.setup

data/lib/kintama/no_conflict.rb

@@ -0,0 +1,2 @@
+ENV["KINTAMA_NO_CONFLICT"] = "true"
+require "kintama"

data/lib/kintama/reporter.rb

@@ -2,7 +2,8 @@ module Kintama
   class Reporter
 
     def self.default
-      Verbose.new(colour=$stdin.tty?)
+      colour = $stdin.tty?
+      Verbose.new(colour)
     end
 
     def self.called(name)
@@ -17,9 +18,9 @@ module Kintama
     end
 
     class Base
-      attr_reader :runner
+      attr_reader :runner, :test_count
 
-      def initialize
+      def initialize(*args)
         @test_count = 0
       end
 
@@ -65,7 +66,7 @@ module Kintama
       end
 
       def character_status_of(test)
-        character = if test.pending?
+        if test.pending?
           'P'
         elsif test.passed?
           '.'
@@ -139,22 +140,22 @@ module Kintama
         end
       end
 
-      def color(text, color_code)
-        "#{color_code}#{text}\e[0m"
+      def colour(text, colour_code)
+        "#{colour_code}#{text}\e[0m"
       end
 
       def green(text)
-        color(text, "\e[32m")
+        colour(text, "\e[32m")
       end
 
       def red(text)
-        color(text, "\e[31m")
+        colour(text, "\e[31m")
       end
 
       def yellow(text)
-        color(text, "\e[33m")
+        colour(text, "\e[33m")
       end
     end
 
   end
-end
+end