micro_test 0.2.8 → 0.3.0

data/lib/micro_test/runner.rb

@@ -1,69 +1,65 @@
 module MicroTest
-  module Runner
+  class Runner
     class << self
-      attr_reader :options, :current_test
+      attr_accessor :exit
+    end
 
-      def update(event, arg)
-        send(event, arg) if respond_to?(event)
-      end
+    attr_reader :formatter, :options, :active_test, :duration, :passed, :failed
 
-      def add_test_class(klass)
-        test_classes << klass
-      end
+    def initialize(formatter, options={})
+      @formatter = formatter
+      @options = options
+      reset
+    end
 
-      def test_classes
-        @test_classes ||= []
-      end
+    def run
+      test_classes = MicroTest::Test.subclasses.shuffle
+      tests = test_classes.map{ |klass| klass.tests }.flatten
+      formatter.before_suite(test_classes)
+      start = Time.now
 
-      def file(path)
-        @files ||= {}
-        @files[path] ||= File.read(path).split("\n")
+      test_classes.each do |test_class|
+        formatter.before_class(test_class)
+        test_class.tests.shuffle.each do |test|
+          stop && exit if MicroTest::Runner.exit
+          @active_test = test
+          if options[:async]
+            test.async.invoke(@formatter, @options)
+          else
+            test.invoke(@formatter, @options)
+          end
+        end
+        formatter.after_class(test_class)
       end
 
-      def file_info(callstack_entry)
-        path = callstack_entry[0, callstack_entry.index(/:[0-9]+:/)]
-        file = file(path)
-        line_num = callstack_entry.scan(/:[0-9]+:/).first.gsub(/:/, "").to_i
-        line = file[line_num - 1].strip
-        {
-          :path => path,
-          :file => file,
-          :line => line,
-          :line_num => line_num
-        }
-      end
+      sleep 0.1 while !finished?(tests)
+      @duration = Time.now - start
+      @passed = tests.select{ |test| test.passed? }.count
+      @failed = tests.select{ |test| !test.passed? }.count
+      formatter.after_results(self)
+      formatter.after_suite(test_classes)
+    end
 
-      def assert(value)
-        @failed ||= !value
-        @asserts << file_info(caller[6]).merge(:passed => value)
+    def stop
+      MicroTest::Test.subclasses.each do |subclass|
+        subclass.tests.each { |test| test.terminate }
       end
+      puts
+      sleep 0.5
+      true
+    end
 
-      def run(formatter, opts={})
-        @options = opts
-        @current_test = nil
-        formatter.header
-
-        test_classes.shuffle.each do |test_class|
-          formatter.group test_class
-          test_class.invoke :before, :all
-
-          test_class.tests.keys.shuffle.each do |desc|
-            @current_test = "#{test_class.name} -> test #{desc}"
-            @failed = false
-            @asserts = []
-            test_class.invoke :before, :each
-            start = Time.now
-            test_class.tests[desc].call
-            formatter.test :name => desc, :passed => !@failed, :asserts => @asserts, :duration => Time.now - start
-            test_class.invoke :after, :each
-          end
-
-          test_class.invoke :after, :all
-        end
+    def reset
+      @duration = 0
+      @passed = 0
+      @failed = 0
+    end
 
-        formatter.footer
-      end
+    private
 
+    def finished?(tests)
+      tests.empty? || tests.map{ |test| test.finished? }.uniq == [true]
     end
+
   end
 end

data/lib/micro_test/test.rb

@@ -1,45 +1,83 @@
-require "observer"
-
 module MicroTest
+
+  # Superclass for all test classes.
+  # @example Create a subclass with a test.
+  #   class SimpleTest < MicroTest::Test
+  #     test "common sense" do
+  #       assert 1 > 0
+  #     end
+  #   end
   class Test
     class << self
-      include Observable
 
-      def inherited(subclass)
-        notify(:add_test_class, subclass)
+      # All subclasses of this class.
+      # @return [Array<MicroTest::Test>]
+      def subclasses
+        @subclasses ||= []
       end
 
-      def notify(event, arg)
-        MicroTest::Test.send :changed
-        MicroTest::Test.send :notify_observers, event, arg
+      # All individual tests defined in this class.
+      # @return [Array<MicroTest::TestWrapper>]
+      def tests
+        @tests ||= []
       end
 
-      def callbacks
-        @callbacks ||= { :before => {}, :after => {} }
+      # All files that define subclasses of this class.
+      # @note Primarily used in the context of MicroTest::Test.
+      # @example Files are stored in a Hash with the following format.
+      #   {
+      #     "path/to/file1.rb" => ["line 1", "line 2", "line 3", ...],
+      #     "path/to/file2.rb" => ["line 1", "line 2", "line 3", ...]
+      #   }
+      # @return [Hash]
+      def files
+        @files ||= {}
       end
 
-      def invoke(which, what)
-        callbacks[which][what].call if callbacks[which][what]
+      # Resets the state in preparation for a new test run.
+      def reset
+        tests.each { |test| test.reset }
+        subclasses.each { |subclass| subclass.reset }
       end
 
-      def before(what, &block)
-        callbacks[:before][what] = block
+      # A callback provided by Ruby that is invoked whenever a subclass is created.
+      def inherited(subclass)
+        file_path = caller[0][0, caller[0].index(/:[0-9]+:/)]
+        files[file_path] = File.open(file_path).readlines
+        subclasses << subclass
       end
 
-      def after(what, &block)
-        callbacks[:after][what] = block
+      # Defines a setup method that will run before each individual test.
+      # @param [Symbol] what Deprecated but maintained for backwards compatibility.
+      # @yield A block of code that will serve as the setup method.
+      def before(what=nil, &block)
+        @before = block
       end
 
-      def tests
-        @tests ||= {}
+      # Defines a teardown method that will run after each individual test.
+      # @param [Symbol] what Deprecated but maintained for backwards compatibility.
+      # @yield A block of code that will serve as the teardown method.
+      def after(what=nil, &block)
+        @after = block
       end
 
+      # Defines a test.
+      # Allows subclasses to define tests in their class definition.
+      #
+      # @param [String] desc A description for the test.
+      # @yield A block that defines the test code.
+      #
+      # @example
+      #   class SimpleTest < MicroTest::Test
+      #     test "common sense" do
+      #       assert 1 > 0
+      #     end
+      #   end
       def test(desc, &block)
-        tests[desc] = block
-      end
-
-      def assert(value)
-        notify(:assert, value)
+        wrapper = MicroTest::TestWrapper.new(self, desc, &block)
+        wrapper.create_method(:before, &@before) if @before
+        wrapper.create_method(:after, &@after) if @after
+        tests << wrapper
       end
 
     end

data/lib/micro_test/test_wrapper.rb

@@ -0,0 +1,136 @@
+module MicroTest
+
+  # A wrapper class for individual tests.
+  # Exists for the purpose of isolating the test method inside of a
+  # Celluloid Actor to support asynchronous test runs.
+  class TestWrapper
+    include Celluloid
+    attr_reader :test_class, :desc, :asserts, :duration
+
+    # Constructor.
+    # @param [MicroTest::Test] test_class The test class that defines the test being wrapped.
+    # @param [String] desc The test description.
+    # @yield The block that defines the test code.
+    def initialize(test_class, desc, &block)
+      @test_class = test_class
+      @desc = desc
+      create_method(:test, &block)
+      reset
+    end
+
+    # Creates a method on this instance.
+    # @param [Symbol] name The name of the method.
+    # @yield The block of code that will serve as the method's implementation.
+    def create_method(name, &block)
+      eigen = class << self; self; end
+      eigen.send(:define_method, name, &block)
+    end
+
+    # callback stubs
+    def before; end
+    def after; end
+
+    # Runs the test code.
+    # @formatter [MicroTest::Formatter] The formatter to use.
+    # @options [Hash]
+    def invoke(formatter, options={})
+      reset
+      @formatter = formatter
+      @options = options
+      @formatter.before_test(self)
+      start = Time.now
+      before
+      test
+      @invoked = true
+      after
+      @duration = Time.now - start
+      @formatter.after_test(self)
+    end
+
+    # A basic assert method to be used within tests.
+    #
+    # @param [Object] value The value to assert.
+    #
+    # @example
+    #   class SimpleTest < MicroTest::Test
+    #     test "common sense" do
+    #       assert 1 > 0
+    #     end
+    #   end
+    def assert(value)
+      @asserts << assert_info(caller).merge(:value => value)
+
+      if !value
+        binding.pry(:quiet => true) if @options[:pry]
+        # I don't really like the coupling to the runner here
+        # but I couldn't get an observer to work with celluloid & pry
+        MicroTest::Runner.exit = true if @options[:fail_fast]
+      end
+
+      value
+    end
+
+    # Indicates if this test has finished running.
+    # @return [Boolean]
+    def finished?
+      !@duration.nil?
+    end
+
+    # Indicates if this test passed.
+    def passed?
+      return true if !@invoked || @asserts.empty?
+      return false if @asserts.empty?
+      @asserts.map{ |a| !!a[:value] }.uniq == [true]
+    end
+
+    # Returns a list of all failed asserts.
+    def failed_asserts
+      return [] if passed?
+      @asserts.select { |a| !a[:value] }
+    end
+
+    # Resets this test in preparation for a clean test run.
+    def reset
+      @invoked = false
+      @asserts = []
+      @duration = nil
+    end
+
+    private
+
+    # Builds a Hash of assert information for the given call stack.
+    #
+    # @param [Array<String>] stack The call stack to extract info from.
+    #
+    # @example
+    #   {
+    #     :file_path => "/path/to/test_file.rb",
+    #     :line_num => 100,
+    #     :line => "  assert 'something' do"
+    #   }
+    #
+    # @return [Hash]
+    def assert_info(stack)
+      file_path = stack[0][0, stack[0].index(/:[0-9]+:/)]
+      lines = MicroTest::Test.files[file_path]
+      line_num = line_number(stack, 0)
+      line_index = line_num - 1
+      line = lines[line_index]
+      {
+        :file_path => file_path,
+        :lines => lines,
+        :line_num => line_num,
+        :line => line
+      }
+    end
+
+    # Returns a line number from a call stack.
+    # @param [Array<String>] stack The call stack to pull a path from.
+    # @param [Integer] index The index of the call stack entry to use.
+    # @return [String]
+    def line_number(stack, index)
+      stack[index].scan(/:[0-9]+:/).first.gsub(/:/, "").to_i
+    end
+
+  end
+end

data/lib/micro_test/version.rb

@@ -1,3 +1,3 @@
 module MicroTest
-  VERSION = "0.2.8"
+  VERSION = "0.3.0"
 end

data/lib/micro_test.rb

@@ -1,9 +1,3 @@
-require "bundler"
-Bundler.require :default
-Bundler.require :debug
-
+require "celluloid"
 path = File.join(File.dirname(__FILE__), "micro_test", "*.rb")
 Dir[path].each { |file| require file }
-
-MicroTest::Test.add_observer MicroTest::Runner
-

data/test/color_test.rb

@@ -0,0 +1,45 @@
+unless ENV["MT_DEMO"]
+  class ColorTest < MicroTest::Test
+    class Crayon
+      include MicroTest::Color
+    end
+    CRAYON = Crayon.new
+
+    test "red" do
+      assert MicroTest::Color.red("foo") == "\e[31mfoo\e[0m"
+      assert ColorTest::CRAYON.red("foo") == "\e[31mfoo\e[0m"
+    end
+
+    test "green" do
+      assert MicroTest::Color.green("foo") == "\e[32mfoo\e[0m"
+      assert ColorTest::CRAYON.green("foo") == "\e[32mfoo\e[0m"
+    end
+
+    test "yellow" do
+      assert MicroTest::Color.yellow("foo") == "\e[33mfoo\e[0m"
+      assert ColorTest::CRAYON.yellow("foo") == "\e[33mfoo\e[0m"
+    end
+
+    test "blue" do
+      assert MicroTest::Color.blue("foo") == "\e[34mfoo\e[0m"
+      assert ColorTest::CRAYON.blue("foo") == "\e[34mfoo\e[0m"
+    end
+
+    test "magenta" do
+      assert MicroTest::Color.magenta("foo") == "\e[35mfoo\e[0m"
+      assert ColorTest::CRAYON.magenta("foo") == "\e[35mfoo\e[0m"
+    end
+
+    test "cyan" do
+      assert MicroTest::Color.cyan("foo") == "\e[36mfoo\e[0m"
+      assert ColorTest::CRAYON.cyan("foo") == "\e[36mfoo\e[0m"
+    end
+
+    test "white" do
+      assert MicroTest::Color.white("foo") == "\e[37mfoo\e[0m"
+      assert ColorTest::CRAYON.white("foo") == "\e[37mfoo\e[0m"
+    end
+
+  end
+
+end

data/test/cpu_latency_test.rb

@@ -0,0 +1,28 @@
+if ENV["MT_DEMO"]
+  class TestCPULatency < MicroTest::Test
+
+    before do
+      @count = 35
+    end
+
+    test "fibonacci recursion 1" do
+      @count.times { |i| TestCPULatency.fib(i) }
+      assert true
+    end
+
+    test "fibonacci recursion 2" do
+      @count.times { |i| TestCPULatency.fib(i) }
+      assert true
+    end
+
+    test "fibonacci recursion 3" do
+      @count.times { |i| TestCPULatency.fib(i) }
+      assert true
+    end
+
+    def self.fib(n)
+      n < 2 ? n : fib(n-1) + fib(n-2)
+    end
+
+  end
+end

data/test/fail_test.rb

@@ -0,0 +1,16 @@
+if ENV["MT_DEMO"]
+  class Fail < MicroTest::Test
+
+    before do
+      @var = "fubar"
+    end
+
+    test "fail on purpose" do
+      # Failing on purpose for the demo.
+      # Use pry to check out the current binding.
+      # For example, type @var.
+      assert false
+    end
+
+  end
+end

data/test/io_latency_test.rb

@@ -0,0 +1,20 @@
+if ENV["MT_DEMO"]
+  class TestIOLatency < MicroTest::Test
+
+    test "sleep 1 sec" do
+      sleep 1
+      assert true
+    end
+
+    test "sleep another 1 sec" do
+      sleep 1
+      assert true
+    end
+
+    test "sleep a third 1 sec" do
+      sleep 1
+      assert true
+    end
+
+  end
+end

data/test/runner_test.rb

@@ -0,0 +1,13 @@
+unless ENV["MT_DEMO"]
+  class TestRunner < MicroTest::Test
+
+    before do
+      @runner = MicroTest::Runner.new(MicroTest::Formatter.new)
+    end
+
+    test ".running" do
+      assert true
+    end
+
+  end
+end

data/test/test_test.rb

@@ -1,117 +1,67 @@
-class TestTest < MicroTest::Test
+unless ENV["MT_DEMO"]
+  class TestTest < MicroTest::Test
 
-  before :each do
-    @Test = Class.new(MicroTest::Test)
-  end
-
-  test "interface" do
-    assert @Test.respond_to?(:inherited)
-    assert @Test.respond_to?(:notify)
-    assert @Test.respond_to?(:callbacks)
-    assert @Test.respond_to?(:invoke)
-    assert @Test.respond_to?(:before)
-    assert @Test.respond_to?(:after)
-    assert @Test.respond_to?(:tests)
-    assert @Test.respond_to?(:test)
-    assert @Test.respond_to?(:assert)
-  end
-
-  test "callbacks data structure" do
-    assert @Test.callbacks.is_a?(Hash)
-    assert @Test.callbacks[:before].is_a?(Hash)
-    assert @Test.callbacks[:after].is_a?(Hash)
-  end
-
-  test "notify" do
-    observer = Class.new do
-      def update(event, arg)
-        (@events ||= {})[event] = arg
+    before do
+      TestTest.instance_eval { @subclasses = [] }
+      TestTest.instance_eval { @tests = [] }
+      @Example = Class.new(TestTest) do
+        before {}
+        after {}
+        test("truth") { assert true }
       end
+      @before_callback = @Example.before
+      @after_callback = @Example.after
     end
-    o = observer.new
-    MicroTest::Test.add_observer o
-    MicroTest::Test.notify(:foo, :bar)
-    events = o.instance_eval { @events }
-    assert events[:foo] == :bar
-  end
 
-  test "notification when inherited" do
-    observer = Class.new do
-      def update(event, arg)
-        (@events ||= {})[event] = arg
-      end
+    test "adds subclass" do
+      assert TestTest.subclasses.length == 1
+      assert TestTest.subclasses[0] == @Example
     end
-    o = observer.new
-    MicroTest::Test.add_observer o
-    t = Class.new(MicroTest::Test)
-    events = o.instance_eval { @events }
-    assert events[:add_test_class] == t
-  end
 
-  test "callbacks" do
-    a = lambda {}
-    b = lambda {}
-    c = lambda {}
-    d = lambda {}
-    @Test.before(:all, &a)
-    @Test.before(:each, &b)
-    @Test.after(:each, &c)
-    @Test.after(:all, &d)
-    assert @Test.callbacks[:before][:all].equal?(a)
-    assert @Test.callbacks[:before][:each].equal?(b)
-    assert @Test.callbacks[:after][:each].equal?(c)
-    assert @Test.callbacks[:after][:all].equal?(d)
-  end
-
-  test "invoke callbacks" do
-    before_all = false
-    before_each = false
-    after_each = false
-    after_all = false
-    @Test.before(:all) { before_all = true }
-    @Test.before(:each) { before_each = true }
-    @Test.after(:each) { after_each = true }
-    @Test.after(:all) { after_all = true }
-    @Test.invoke(:before, :all)
-    @Test.invoke(:before, :each)
-    @Test.invoke(:after, :each)
-    @Test.invoke(:after, :all)
-    assert before_all
-    assert before_each
-    assert after_each
-    assert after_all
-  end
+    test "stores subclasses" do
+      assert TestTest.subclasses.is_a?(Array)
+      assert TestTest.subclasses.length == 1
+      assert TestTest.subclasses.first == @Example
+    end
 
-  test "tests" do
-    assert MicroTest::Test.tests.is_a?(Hash)
-  end
+    test "stores tests" do
+      assert @Example.tests.is_a?(Array)
+      assert @Example.tests.length == 1
+      assert @Example.tests.first.is_a?(MicroTest::TestWrapper)
+    end
 
-  test "add tests" do
-    a = lambda {}
-    b = lambda {}
-    c = lambda {}
-    @Test.test("a", &a)
-    @Test.test("b", &b)
-    @Test.test("c", &c)
-    assert @Test.tests["a"].equal?(a)
-    assert @Test.tests["b"].equal?(b)
-    assert @Test.tests["c"].equal?(c)
-  end
+    test "stores files" do
+      file = __FILE__
+      assert TestTest.files[file].is_a?(Array)
+      assert TestTest.files[file].select{ |l| l.start_with?("      assert TestTest.files[file].select{ |l| l.start_with?(") }.length > 0
+    end
 
-  test "assert" do
-    observer = Class.new do
-      def update(event, arg)
-        (@events ||= {})[event] = arg
+    test ".reset" do
+      @Example.tests.first.instance_eval do
+        @asserts = nil
+        @duration = nil
       end
+      @Example.reset
+      assert @Example.tests.length == 1
+      assert @Example.tests.first.asserts == []
+      assert @Example.tests.first.duration == nil
+    end
+
+    test ".before" do
+      assert @Example.instance_eval { @before } == @before_callback
     end
-    o = observer.new
-    MicroTest::Test.add_observer o
-    @Test.test "assert test" do
-      assert true
+
+    test ".after" do
+      assert @Example.instance_eval { @after } == @after_callback
     end
-    @Test.tests["assert test"].call
-    events = o.instance_eval { @events }
-    assert events[:assert] == true
-  end
 
+    test "tests" do
+      t = lambda {}
+      @Example.send :test, :add_a_test, &t
+      assert @Example.tests.length == 2
+      assert @Example.tests.last.is_a?(MicroTest::TestWrapper)
+      assert @Example.tests.last.desc == :add_a_test
+    end
+
+  end
 end