newbamboo-rspec 1.1.12

data/lib/spec/runner/configuration.rb

@@ -0,0 +1,166 @@
+module Spec
+  module Runner
+    class Configuration
+      # Chooses what mock framework to use. Example:
+      #
+      #   Spec::Runner.configure do |config|
+      #     config.mock_with :rspec, :mocha, :flexmock, or :rr
+      #   end
+      #
+      # To use any other mock framework, you'll have to provide your own
+      # adapter. This is simply a module that responds to the following
+      # methods:
+      #
+      #   setup_mocks_for_rspec
+      #   verify_mocks_for_rspec
+      #   teardown_mocks_for_rspec.
+      #
+      # These are your hooks into the lifecycle of a given example. RSpec will
+      # call setup_mocks_for_rspec before running anything else in each
+      # Example. After executing the #after methods, RSpec will then call
+      # verify_mocks_for_rspec and teardown_mocks_for_rspec (this is
+      # guaranteed to run even if there are failures in
+      # verify_mocks_for_rspec).
+      #
+      # Once you've defined this module, you can pass that to mock_with:
+      #
+      #   Spec::Runner.configure do |config|
+      #     config.mock_with MyMockFrameworkAdapter
+      #   end
+      #
+      def mock_with(mock_framework)
+        @mock_framework = case mock_framework
+        when Symbol
+          mock_framework_path(mock_framework.to_s)
+        else
+          mock_framework
+        end
+      end
+      
+      def mock_framework # :nodoc:
+        @mock_framework ||= mock_framework_path("rspec")
+      end
+      
+      # :call-seq:
+      #   include(Some::Helpers)
+      #   include(Some::Helpers, More::Helpers)
+      #   include(My::Helpers, :type => :key)
+      #
+      # Declares modules to be included in multiple example groups
+      # (<tt>describe</tt> blocks). With no <tt>:type</tt>, the modules listed
+      # will be included in all example groups.
+      #
+      # Use <tt>:type</tt> to restrict
+      # the inclusion to a subset of example groups. The value assigned to
+      # <tt>:type</tt> should be a key that maps to a class that is either a
+      # subclass of Spec::Example::ExampleGroup or extends
+      # Spec::Example::ExampleGroupMethods and includes
+      # Spec::Example::ExampleMethods.
+      #
+      # For example, the rspec-rails gem/plugin extends Test::Unit::TestCase
+      # with Spec::Example::ExampleGroupMethods and includes
+      # Spec::Example::ExampleMethods in it. So if you have a module of helper
+      # methods for controller examples, you could do this:
+      #
+      #   config.include(ControllerExampleHelpers, :type => :controller)
+      #
+      # Only example groups that have that type will get the modules included:
+      #
+      #   describe Account, :type => :model do
+      #     # Will *not* include ControllerExampleHelpers
+      #   end
+      #
+      #   describe AccountsController, :type => :controller do
+      #     # *Will* include ControllerExampleHelpers
+      #   end
+      #
+      def include(*args)
+        include_or_extend(:include, *args)
+      end
+      
+      # :call-seq:
+      #   extend(Some::Helpers)
+      #   extend(Some::Helpers, More::Helpers)
+      #   extend(My::Helpers, :type => :key)
+      #
+      # Works just like #include, but extends the example groups
+      # with the modules rather than including them.
+      def extend(*args)
+        include_or_extend(:extend, *args)
+      end
+      
+      # Defines global predicate matchers. Example:
+      #
+      #   config.predicate_matchers[:swim] = :can_swim?
+      #
+      # This makes it possible to say:
+      #
+      #   person.should swim # passes if person.can_swim? returns true
+      #
+      def predicate_matchers
+        @predicate_matchers ||= {}
+      end
+      
+      # Prepends a global <tt>before</tt> block to all example groups.
+      # See #append_before for filtering semantics.
+      def prepend_before(*args, &proc)
+        add_callback(:prepend_before, *args, &proc)
+      end
+      
+      # Appends a global <tt>before</tt> block to all example groups.
+      #
+      # If you want to restrict the block to a subset of all the example
+      # groups then specify this in a Hash as the last argument:
+      #
+      #   config.prepend_before(:all, :type => :farm)
+      #
+      # or
+      #
+      #   config.prepend_before(:type => :farm)
+      #
+      def append_before(*args, &proc)
+        add_callback(:append_before, *args, &proc)
+      end
+      alias_method :before, :append_before
+
+      # Prepends a global <tt>after</tt> block to all example groups.
+      # See #append_before for filtering semantics.
+      def prepend_after(*args, &proc)
+        add_callback(:prepend_after, *args, &proc)
+      end
+      alias_method :after, :prepend_after
+      
+      # Appends a global <tt>after</tt> block to all example groups.
+      # See #append_before for filtering semantics.
+      def append_after(*args, &proc)
+        add_callback(:append_after, *args, &proc)
+      end
+
+    private
+    
+      def include_or_extend(action, *args)
+        modules, options = Spec::Example.args_and_options(*args)
+        [get_type_from_options(options)].flatten.each do |required_example_group|
+          required_example_group = required_example_group.to_sym if required_example_group
+          modules.each do |mod|
+            Spec::Example::ExampleGroupFactory.get(required_example_group).__send__(action, mod)
+          end
+        end
+      end
+
+      def add_callback(sym, *args, &proc)
+        scope, options = Spec::Example.scope_and_options(*args)
+        example_group = Spec::Example::ExampleGroupFactory.get(get_type_from_options(options))
+        example_group.__send__(sym, scope, &proc)
+      end
+
+      def get_type_from_options(options)
+        options[:type] || options[:behaviour_type]
+      end
+    
+      def mock_framework_path(framework_name)
+        File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "adapters", "mock_frameworks", framework_name))
+      end
+    end
+  end
+end

data/lib/spec/runner/drb_command_line.rb

@@ -0,0 +1,20 @@
+require "drb/drb"
+
+module Spec
+  module Runner
+    # Facade to run specs by connecting to a DRB server
+    class DrbCommandLine
+      # Runs specs on a DRB server. Note that this API is similar to that of
+      # CommandLine - making it possible for clients to use both interchangeably.
+      def self.run(options)
+        begin
+          DRb.start_service
+          spec_server = DRbObject.new_with_uri("druby://127.0.0.1:8989")
+          spec_server.run(options.argv, options.error_stream, options.output_stream)
+        rescue DRb::DRbConnError => e
+          options.error_stream.puts "No server is running"
+        end
+      end
+    end
+  end
+end

data/lib/spec/runner/example_group_runner.rb

@@ -0,0 +1,70 @@
+module Spec
+  module Runner
+    class ExampleGroupRunner
+      def initialize(options)
+        @options = options
+      end
+
+      def load_files(files)
+        # It's important that loading files (or choosing not to) stays the
+        # responsibility of the ExampleGroupRunner. Some implementations (like)
+        # the one using DRb may choose *not* to load files, but instead tell
+        # someone else to do it over the wire.
+        $KCODE = 'u' if RUBY_VERSION < '1.9'
+        files.each do |file|
+          load file
+        end
+      end
+
+      def run
+        prepare
+        success = true
+        example_groups.each do |example_group|
+          success = success & example_group.run(@options)
+        end
+        return success
+      ensure
+        finish
+      end
+
+      protected
+      def prepare
+        reporter.start(number_of_examples)
+        example_groups.reverse! if reverse
+      end
+
+      def finish
+        reporter.end
+        reporter.dump
+      end
+
+      def reporter
+        @options.reporter
+      end
+
+      def reverse
+        @options.reverse
+      end
+
+      def example_groups
+        @options.example_groups
+      end
+
+      def number_of_examples
+        @options.number_of_examples
+      end
+    end
+    
+    class BehaviourRunner < ExampleGroupRunner
+      def initialize(options)
+        Kernel.warn <<-WARNING
+DEPRECATED: The BeheviourRunner class is deprecated and will
+be removed from rspec-1.2.
+
+Use ExampleGroupRunner instead.
+WARNING
+        super
+      end
+    end
+  end
+end

data/lib/spec/runner/formatter/base_formatter.rb

@@ -0,0 +1,79 @@
+module Spec
+  module Runner
+    module Formatter
+      # Baseclass for formatters that implements all required methods as no-ops. 
+      class BaseFormatter
+        attr_accessor :example_group, :options, :where
+        def initialize(options, where)
+          @options = options
+          @where = where
+        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_example_group
+        def start(example_count)
+        end
+
+        # This method is invoked at the beginning of the execution of each example_group.
+        # +example_group+ is the example_group.
+        #
+        # The next method to be invoked after this is #example_failed or #example_finished
+        def add_example_group(example_group)
+          @example_group = example_group
+        end
+
+        # This method is invoked when an +example+ starts.
+        def example_started(example)
+        end
+
+        # This method is invoked when an +example+ passes.
+        def example_passed(example)
+        end
+
+        # This method is invoked when an +example+ fails, i.e. an exception occurred
+        # inside it (such as a failed should or other exception). +counter+ is the 
+        # sequence number of the failure (starting at 1) and +failure+ is the associated 
+        # Failure object.
+        def example_failed(example, counter, failure)
+        end
+        
+        # This method is invoked when an example is not yet implemented (i.e. has not
+        # been provided a block), or when an ExamplePendingError is raised.
+        # +message+ is the message from the ExamplePendingError, if it exists, or the
+        # default value of "Not Yet Implemented"
+        # +pending_caller+ is the file and line number of the spec which
+        # has called the pending method
+        def example_pending(example, message, pending_caller)
+        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
+        end
+
+        # Dumps detailed information about an example failure.
+        # This method is invoked for each failed example after all examples have run. +counter+ is the sequence number
+        # of the associated example. +failure+ is a Failure object, which contains detailed
+        # information about the failure.
+        def dump_failure(counter, failure)
+        end
+      
+        # This method is invoked after the dumping of examples and failures.
+        def dump_summary(duration, example_count, failure_count, pending_count)
+        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
+      end
+    end
+  end
+end

data/lib/spec/runner/formatter/base_text_formatter.rb

@@ -0,0 +1,127 @@
+require 'spec/runner/formatter/base_formatter'
+
+module Spec
+  module Runner
+    module Formatter
+      # Baseclass for text-based formatters. Can in fact be used for
+      # non-text based ones too - just ignore the +output+ constructor
+      # argument.
+      class BaseTextFormatter < BaseFormatter
+        attr_reader :output, :pending_examples
+        # Creates a new instance that will write to +where+. If +where+ is a
+        # String, output will be written to the File with that name, otherwise
+        # +where+ is exected to be an IO (or an object that responds to #puts and #write).
+        def initialize(options, where)
+          super
+          if where.is_a?(String)
+            FileUtils.mkdir_p(File.dirname(where))
+            @output = File.open(where, 'w')
+          else
+            @output = where
+          end
+          @pending_examples = []
+        end
+        
+        def example_pending(example, message, pending_caller)
+          @pending_examples << [example.full_description, message, pending_caller]
+        end
+        
+        def dump_failure(counter, failure)
+          @output.puts
+          @output.puts "#{counter.to_s})"
+          @output.puts colourise("#{failure.header}\n#{failure.exception.message}", failure)
+          @output.puts format_backtrace(failure.exception.backtrace)
+          @output.flush
+        end
+        
+        def colourise(s, failure)
+          if(failure.expectation_not_met?)
+            red(s)
+          elsif(failure.pending_fixed?)
+            blue(s)
+          else
+            magenta(s)
+          end
+        end
+      
+        def dump_summary(duration, example_count, failure_count, pending_count)
+          return if dry_run?
+          @output.puts
+          @output.puts "Finished in #{duration} seconds"
+          @output.puts
+
+          summary = "#{example_count} example#{'s' unless example_count == 1}, #{failure_count} failure#{'s' unless failure_count == 1}"
+          summary << ", #{pending_count} pending" if pending_count > 0  
+
+          if failure_count == 0
+            if pending_count > 0
+              @output.puts yellow(summary)
+            else
+              @output.puts green(summary)
+            end
+          else
+            @output.puts red(summary)
+          end
+          @output.flush
+        end
+
+        def dump_pending
+          unless @pending_examples.empty?
+            @output.puts
+            @output.puts "Pending:"
+            @pending_examples.each do |pending_example|
+              @output.puts "\n#{pending_example[0]} (#{pending_example[1]})"
+              @output.puts "#{pending_example[2]}\n"
+            end
+          end
+          @output.flush
+        end
+        
+        def close
+          if IO === @output && @output != $stdout
+            @output.close 
+          end
+        end
+        
+        def format_backtrace(backtrace)
+          return "" if backtrace.nil?
+          backtrace.map { |line| backtrace_line(line) }.join("\n")
+        end
+      
+      protected
+
+        def colour?
+          @options.colour ? true : false
+        end
+
+        def dry_run?
+          @options.dry_run ? true : false
+        end
+        
+        def backtrace_line(line)
+          line.sub(/\A([^:]+:\d+)$/, '\\1:')
+        end
+
+        def colour(text, colour_code)
+          return text unless colour? && output_to_tty?
+          "#{colour_code}#{text}\e[0m"
+        end
+
+        def output_to_tty?
+          begin
+            @output.tty? || ENV.has_key?("AUTOTEST")
+          rescue NoMethodError
+            false
+          end
+        end
+        
+        def green(text); colour(text, "\e[32m"); end
+        def red(text); colour(text, "\e[31m"); end
+        def magenta(text); colour(text, "\e[35m"); end
+        def yellow(text); colour(text, "\e[33m"); end
+        def blue(text); colour(text, "\e[34m"); end
+        
+      end
+    end
+  end
+end

data/lib/spec/runner/formatter/failing_example_groups_formatter.rb

@@ -0,0 +1,27 @@
+require 'spec/runner/formatter/base_text_formatter'
+
+module Spec
+  module Runner
+    module Formatter
+      class FailingExampleGroupsFormatter < BaseTextFormatter
+        def example_failed(example, counter, failure)
+          if @example_group
+            description_parts = @example_group.description_parts.collect do |description|
+              description =~ /(.*) \(druby.*\)$/ ? $1 : description
+            end
+            @output.puts ::Spec::Example::ExampleGroupMethods.description_text(*description_parts)
+
+            @output.flush
+            @example_group = nil
+          end
+        end
+
+        def dump_failure(counter, failure)
+        end
+
+        def dump_summary(duration, example_count, failure_count, pending_count)
+        end
+      end
+    end
+  end
+end

data/lib/spec/runner/formatter/failing_examples_formatter.rb

@@ -0,0 +1,20 @@
+require 'spec/runner/formatter/base_text_formatter'
+
+module Spec
+  module Runner
+    module Formatter
+      class FailingExamplesFormatter < BaseTextFormatter      
+        def example_failed(example, counter, failure)
+          @output.puts "#{example_group.description} #{example.description}"
+          @output.flush
+        end
+
+        def dump_failure(counter, failure)
+        end
+
+        def dump_summary(duration, example_count, failure_count, pending_count)
+        end
+      end
+    end
+  end
+end