micronaut 0.2.9

data/lib/micronaut/example.rb

@@ -0,0 +1,112 @@
+module Micronaut
+
+  class Example
+  
+    attr_reader :behaviour, :description, :metadata, :example_block
+  
+    def initialize(behaviour, desc, options, example_block=nil)
+      @behaviour, @description, @options, @example_block = behaviour, desc, options, example_block
+      @metadata = @behaviour.metadata.dup
+      @metadata[:description] = description
+      @metadata[:execution_result] = {}
+      @metadata[:caller] = options.delete(:caller)
+      if @metadata[:caller]
+        @metadata[:file_path] = @metadata[:caller].split(":")[0].strip 
+        @metadata[:line_number] = @metadata[:caller].split(":")[1].to_i
+      end
+      @metadata.update(options)
+    end
+
+    def record_results(results={})
+      @metadata[:execution_result].update(results)
+    end
+
+    def execution_result
+      @metadata[:execution_result]
+    end
+    
+    def file_path
+      @metadata[:file_path] || behaviour.file_path
+    end
+    
+    def run_started
+      record_results :started_at => Time.now
+    end
+
+    def run_passed
+      run_finished 'passed'
+    end
+
+    def run_pending(message='Not yet implemented')
+      run_finished 'pending', :pending_message => message
+    end
+
+    def run_failed(exception)
+      run_finished 'failed', :exception_encountered => exception
+    end
+
+    def run_finished(status, results={})
+      record_results results.update(:status => status)
+      finish_time = Time.now
+      record_results :finished_at => finish_time, :run_time => (finish_time - execution_result[:started_at])
+      Micronaut.configuration.formatter.example_finished(self)
+    end
+
+    def run_before_each
+      @behaviour_instance._setup_mocks if @behaviour_instance.respond_to?(:_setup_mocks)
+      @behaviour.eval_before_eachs(@behaviour_instance)
+    end
+
+    def run_after_each
+      @behaviour.eval_after_eachs(@behaviour_instance)
+      @behaviour_instance._verify_mocks if @behaviour_instance.respond_to?(:_verify_mocks)
+    ensure
+      @behaviour_instance._teardown_mocks if @behaviour_instance.respond_to?(:_teardown_mocks)
+    end
+
+    def run(behaviour_instance)
+      @behaviour_instance = behaviour_instance
+      @behaviour_instance.running_example = self
+
+      run_started
+
+      all_systems_nominal = true
+      exception_encountered = nil
+      
+      begin
+        run_before_each
+        @behaviour_instance.instance_eval(&example_block) if example_block
+      rescue Exception => e
+        exception_encountered = e
+        all_systems_nominal = false
+      end
+
+      begin
+        run_after_each
+      rescue Exception => e
+        exception_encountered ||= e
+        all_systems_nominal = false
+      ensure
+        @behaviour_instance.running_example = nil
+      end
+      
+      if exception_encountered
+        run_failed(exception_encountered) 
+      else
+        example_block ? run_passed : run_pending
+      end
+
+      all_systems_nominal
+    end
+
+    def inspect
+      "#{@metadata[:behaviour][:name]} - #{@metadata[:description]}"
+    end
+    
+    def to_s
+      inspect
+    end
+  
+  end
+  
+end

data/lib/micronaut/expectations.rb

@@ -0,0 +1,45 @@
+require 'micronaut/matchers'
+require 'micronaut/expectations/extensions/object'
+require 'micronaut/expectations/handler'
+require 'micronaut/expectations/wrap_expectation'
+
+module Micronaut
+
+  # Micronaut::Expectations lets you set expectations on your objects.
+  #
+  #   result.should == 37
+  #   team.should have(11).players_on_the_field
+  #
+  # == How Expectations work.
+  #
+  # Micronaut::Expectations adds two methods to Object:
+  #
+  #   should(matcher=nil)
+  #   should_not(matcher=nil)
+  #
+  # Both methods take an optional Expression Matcher (See Micronaut::Matchers).
+  #
+  # When +should+ receives an Expression Matcher, it calls <tt>matches?(self)</tt>. If
+  # it returns +true+, the spec passes and execution continues. If it returns
+  # +false+, then the spec fails with the message returned by <tt>matcher.failure_message</tt>.
+  #
+  # Similarly, when +should_not+ receives a matcher, it calls <tt>matches?(self)</tt>. If
+  # it returns +false+, the spec passes and execution continues. If it returns
+  # +true+, then the spec fails with the message returned by <tt>matcher.negative_failure_message</tt>.
+  #
+  # Micronaut ships with a standard set of useful matchers, and writing your own
+  # matchers is quite simple. See Micronaut::Matchers for details.
+  module Expectations
+
+    class ExpectationNotMetError < ::StandardError; end
+  
+    def self.fail_with(message, expected=nil, target=nil) # :nodoc:
+      if Array === message && message.length == 3
+        message, expected, target = message[0], message[1], message[2]
+      end
+      Kernel::raise(Micronaut::Expectations::ExpectationNotMetError.new(message))
+    end
+  
+  end
+  
+end

data/lib/micronaut/expectations/extensions/object.rb

@@ -0,0 +1,92 @@
+module Micronaut
+  module Expectations
+    class InvalidMatcherError < ArgumentError; end        
+    
+    module ObjectExpectations
+      # :call-seq:
+      #   should(matcher)
+      #   should == expected
+      #   should === expected
+      #   should =~ expected
+      #
+      #   receiver.should(matcher)
+      #     => Passes if matcher.matches?(receiver)
+      #
+      #   receiver.should == expected #any value
+      #     => Passes if (receiver == expected)
+      #
+      #   receiver.should === expected #any value
+      #     => Passes if (receiver === expected)
+      #
+      #   receiver.should =~ regexp
+      #     => Passes if (receiver =~ regexp)
+      #
+      # See Micronaut::Matchers for more information about matchers
+      #
+      # == Warning
+      # NOTE that this does NOT support receiver.should != expected.
+      # Instead, use receiver.should_not == expected
+      def should(matcher=nil, &block)
+        ::Micronaut::Matchers.last_should = "should"
+        return ::Micronaut::Matchers::PositiveOperatorMatcher.new(self) if matcher.nil?
+
+        unless matcher.respond_to?(:matches?)
+          raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
+        end
+
+        match_found = matcher.matches?(self, &block)
+        ::Micronaut::Matchers.last_matcher = matcher
+        
+        ::Micronaut::Expectations.fail_with(matcher.failure_message) unless match_found
+        match_found
+      end
+
+      # :call-seq:
+      #   should_not(matcher)
+      #   should_not == expected
+      #   should_not === expected
+      #   should_not =~ expected
+      #
+      #   receiver.should_not(matcher)
+      #     => Passes unless matcher.matches?(receiver)
+      #
+      #   receiver.should_not == expected
+      #     => Passes unless (receiver == expected)
+      #
+      #   receiver.should_not === expected
+      #     => Passes unless (receiver === expected)
+      #
+      #   receiver.should_not =~ regexp
+      #     => Passes unless (receiver =~ regexp)
+      #
+      # See Micronaut::Matchers for more information about matchers
+      def should_not(matcher=nil, &block)
+        ::Micronaut::Matchers.last_should = "should not"
+        return ::Micronaut::Matchers::NegativeOperatorMatcher.new(self) if matcher.nil?
+
+        unless matcher.respond_to?(:matches?)
+          raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
+        end
+
+        unless matcher.respond_to?(:negative_failure_message)
+          ::Micronaut::Expectations.fail_with(
+          <<-EOF
+          Matcher does not support should_not.
+          See Micronaut::Matchers for more information about matchers.
+          EOF
+          )
+        end
+        match_found = matcher.matches?(self, &block)
+        ::Micronaut::Matchers.last_matcher = matcher
+        
+        ::Micronaut::Expectations.fail_with(matcher.negative_failure_message) if match_found
+        match_found
+      end
+
+    end
+  end
+end
+
+class Object
+  include Micronaut::Expectations::ObjectExpectations
+end

data/lib/micronaut/expectations/handler.rb

@@ -0,0 +1,51 @@
+module Micronaut
+  module Expectations
+    
+
+    # class ExpectationMatcherHandler        
+    # 
+    #      def self.handle_matcher(actual, matcher, &block)
+    #        ::Micronaut::Matchers.last_should = "should"
+    #        return Micronaut::Matchers::PositiveOperatorMatcher.new(actual) if matcher.nil?
+    # 
+    #        unless matcher.respond_to?(:matches?)
+    #          raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
+    #        end
+    # 
+    #        match = matcher.matches?(actual, &block)
+    #        ::Micronaut::Matchers.last_matcher = matcher
+    #        Micronaut::Expectations.fail_with(matcher.failure_message) unless match
+    #        match
+    #      end
+    # 
+    #    end
+
+    # class NegativeExpectationMatcherHandler
+    # 
+    #      def self.handle_matcher(actual, matcher, &block)
+    #        ::Micronaut::Matchers.last_should = "should not"
+    #        return Micronaut::Matchers::NegativeOperatorMatcher.new(actual) if matcher.nil?
+    # 
+    #        unless matcher.respond_to?(:matches?)
+    #          raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
+    #        end
+    # 
+    #        unless matcher.respond_to?(:negative_failure_message)
+    #          Micronaut::Expectations.fail_with(
+    #          <<-EOF
+    #          Matcher does not support should_not.
+    #          See Micronaut::Matchers for more information
+    #          about matchers.
+    #          EOF
+    #          )
+    #        end
+    #        match = matcher.matches?(actual, &block)
+    #        ::Micronaut::Matchers.last_matcher = matcher
+    #        Micronaut::Expectations.fail_with(matcher.negative_failure_message) if match
+    #        match
+    #      end
+   
+    # end
+
+  end
+end

data/lib/micronaut/expectations/wrap_expectation.rb

@@ -0,0 +1,52 @@
+module Micronaut
+  module Matchers
+    
+    # wraps an expectation in a block that will return true if the
+    # expectation passes and false if it fails (without bubbling up
+    # the failure).
+    #     
+    # This is intended to be used in the context of a simple matcher,
+    # and is especially useful for wrapping multiple expectations or
+    # one or more assertions from test/unit extensions when running
+    # with test/unit.
+    #
+    # == Examples
+    #
+    #   def eat_cheese(cheese)
+    #     simple_matcher do |mouse, matcher|
+    #       matcher.negative_failure_message = "expected #{mouse} not to eat cheese"
+    #       wrap_expectation do |matcher|
+    #         assert_eats_cheese(mouse)
+    #       end
+    #     end
+    #   end
+    #
+    #   describe Mouse do
+    #     it "eats cheese" do
+    #       Mouse.new.should eat_cheese
+    #     end
+    #   end
+    #
+    # The other benefit you get is that you can use the negative version
+    # of the matcher:
+    #
+    #   describe Cat do
+    #     it "does not eat cheese" do
+    #       Cat.new.should_not eat_cheese
+    #     end
+    #   end
+    #
+    # So in the event there is no assert_does_not_eat_cheese available,
+    # you're all set!
+    def wrap_expectation(matcher, &block)
+      begin
+        block.call(matcher)
+        return true
+      rescue Exception => e
+        matcher.failure_message = e.message
+        return false
+      end
+    end
+
+  end
+end

data/lib/micronaut/formatters.rb

@@ -0,0 +1,12 @@
+require 'micronaut/formatters/base_formatter'
+require 'micronaut/formatters/base_text_formatter'
+require 'micronaut/formatters/documentation_formatter'
+require 'micronaut/formatters/progress_formatter'
+
+module Micronaut
+  
+  module Formatters
+    
+  end
+  
+end

data/lib/micronaut/formatters/base_formatter.rb

@@ -0,0 +1,127 @@
+module Micronaut
+  module Formatters
+
+    class BaseFormatter
+      attr_accessor :behaviour
+      attr_reader :example_count, :duration, :examples
+      
+      def initialize
+        @example_count = 0
+        @examples = []
+        @behaviour = nil
+      end
+      
+      def configuration
+        Micronaut.configuration
+      end
+      
+      def output
+        Micronaut.configuration.output
+      end
+      
+      def trace(&blk)
+        Micronaut.configuration.trace(trace_override_flag, &blk)
+      end
+      
+      # Allow setting trace at the behaviour level as well globally
+      def trace_override_flag
+        behaviour && behaviour.metadata[:trace]
+      end
+      
+      def profile_examples?
+        Micronaut.configuration.profile_examples
+      end
+      
+      def color_enabled?
+        configuration.color_enabled?
+      end
+      
+      def pending_examples
+        @pending_examples ||= ::Micronaut.world.find(examples, :execution_result => { :status => 'pending' })
+      end
+      
+      def failed_examples
+        @failed_examples ||= ::Micronaut.world.find(examples, :execution_result => { :status => 'failed' })
+      end
+
+      # This method is invoked before any examples are run, right after
+      # they have all been collected. This can be useful for special
+      # formatters that need to provide progress on feedback (graphical ones)
+      #
+      # This method will only be invoked once, and the next one to be invoked
+      # is #add_behaviour
+      def start(example_count)
+        @example_count = example_count
+      end
+
+      def example_finished(example)
+        examples << example
+      end
+
+      # This method is invoked at the beginning of the execution of each behaviour.
+      # +behaviour+ is the behaviour.
+      #
+      # The next method to be invoked after this is #example_failed or #example_finished
+      def add_behaviour(behaviour)
+        @behaviour = behaviour
+      end
+
+      # This method is invoked after all of the examples have executed. The next method
+      # to be invoked after this one is #dump_failure (once for each failed example),
+      def start_dump(duration)
+        @duration = duration
+      end
+
+      # Dumps detailed information about each example failure.
+      def dump_failures
+      end
+
+      # This method is invoked after the dumping of examples and failures.
+      def dump_summary
+      end
+
+      # This gets invoked after the summary if option is set to do so.
+      def dump_pending
+      end
+
+      # This method is invoked at the very end. Allows the formatter to clean up, like closing open streams.
+      def close
+      end
+      
+      def format_backtrace(backtrace, example)
+        return "" unless backtrace
+        return backtrace if example.metadata[:full_backtrace] == true
+
+        cleansed = backtrace.select { |line| backtrace_line(line) }
+        # Kick the describe stack info off the list, just keep the line the problem happened on from that file
+        # cleansed = [cleansed.detect { |line| line.split(':').first == example.metadata[:caller].split(':').first }] if cleansed.size > 1 
+        cleansed.empty? ? backtrace : cleansed
+      end
+      
+      protected
+
+      def backtrace_line(line)
+        return nil if configuration.cleaned_from_backtrace?(line)
+        line.sub!(/\A([^:]+:\d+)$/, '\\1')
+        return nil if line == '-e:1'
+        line
+      end
+      
+      def read_failed_line(exception, example)
+        original_file = example.file_path.to_s.downcase
+        matching_line = exception.backtrace.detect { |line| line.split(':').first.downcase == original_file.downcase }
+
+        return "Unable to find matching line from backtrace" if matching_line.nil?
+        
+        file_path, line_number = matching_line.split(':')
+        if File.exist?(file_path)
+          open(file_path, 'r') { |f| f.readlines[line_number.to_i - 1] }
+        else
+          "Unable to find #{file_path} to read failed line"
+        end
+      end
+      
+    end
+    
+  end
+end