puppet 0.18.4 → 0.22.4

data/test/lib/spec/runner/formatter/progress_bar_formatter.rb

@@ -0,0 +1,27 @@
+module Spec
+  module Runner
+    module Formatter
+      class ProgressBarFormatter < BaseTextFormatter
+        def add_context(name, first)
+          @output.puts if first
+          STDOUT.flush
+        end
+      
+        def spec_failed(name, counter, failure)
+          @output.print failure.expectation_not_met? ? red('F') : magenta('F')
+          STDOUT.flush
+        end
+
+        def spec_passed(name)
+          @output.print green('.')
+          STDOUT.flush
+        end
+      
+        def start_dump
+          @output.puts
+          STDOUT.flush
+        end
+      end
+    end
+  end
+end

data/test/lib/spec/runner/formatter/rdoc_formatter.rb

@@ -0,0 +1,22 @@
+module Spec
+  module Runner
+    module Formatter
+      class RdocFormatter < BaseTextFormatter
+        def add_context(name, first)
+          @output.print "# #{name}\n"
+          STDOUT.flush
+        end
+  
+        def spec_passed(name)
+          @output.print "# * #{name}\n"
+          STDOUT.flush
+        end
+
+        def spec_failed(name, counter, failure)
+          @output.print "# * #{name} [#{counter} - FAILED]\n"
+          STDOUT.flush
+        end
+      end
+    end
+  end
+end

data/test/lib/spec/runner/formatter/specdoc_formatter.rb

@@ -0,0 +1,23 @@
+module Spec
+  module Runner
+    module Formatter
+      class SpecdocFormatter < BaseTextFormatter      
+        def add_context(name, first)
+          @output.puts
+          @output.puts name
+          STDOUT.flush
+        end
+      
+        def spec_failed(name, counter, failure)
+          @output.puts failure.expectation_not_met? ? red("- #{name} (FAILED - #{counter})") : magenta("- #{name} (ERROR - #{counter})")
+          STDOUT.flush
+        end
+      
+        def spec_passed(name)
+          @output.print green("- #{name}\n")
+          STDOUT.flush
+        end
+      end
+    end
+  end
+end

data/test/lib/spec/runner/heckle_runner.rb

@@ -0,0 +1,71 @@
+begin
+  require 'rubygems'
+  require 'heckle'
+rescue LoadError ; raise "You must gem install heckle to use --heckle" ; end
+
+module Spec
+  module Runner
+    # Creates a new Heckler configured to heckle all methods in the classes
+    # whose name matches +filter+
+    class HeckleRunner
+      def initialize(filter, heckle_class=Heckler)
+        @filter = filter
+        @heckle_class = heckle_class
+      end
+      
+      # Runs all the contexts held by +context_runner+ once for each of the 
+      # methods in the matched classes.
+      def heckle_with(context_runner)
+        if @filter =~ /(.*)[#\.](.*)/
+          heckle_method($1, $2)
+        else
+          heckle_class_or_module(@filter)
+        end
+      end
+      
+      def heckle_method(class_name, method_name)
+        verify_constant(class_name)
+        heckle = @heckle_class.new(class_name, method_name, context_runner)
+        heckle.validate
+      end
+      
+      def heckle_class_or_module(class_or_module_name)
+        verify_constant(class_or_module_name)
+        pattern = /^#{class_or_module_name}/
+        classes = []
+        ObjectSpace.each_object(Class) do |klass|
+          classes << klass if klass.name =~ pattern
+        end
+        
+        classes.each do |klass|
+          klass.instance_methods(false).each do |method_name|
+            heckle = @heckle_class.new(klass.name, method_name, context_runner)
+            heckle.validate
+          end
+        end
+      end
+      
+      def verify_constant(name)
+        begin
+          # This is defined in Heckle
+          name.to_class
+        rescue
+          raise "Heckling failed - \"#{name}\" is not a known class or module"
+        end
+      end
+    end
+    
+    #Supports Heckle 1.2 and prior (earlier versions used Heckle::Base)
+    class Heckler < (Heckle.const_defined?(:Base) ? Heckle::Base : Heckle)
+      def initialize(klass_name, method_name, context_runner)
+        super(klass_name, method_name)
+        @context_runner = context_runner
+      end
+
+      def tests_pass?
+        failure_count = @context_runner.run(false)
+        failure_count == 0
+      end
+    end
+  end
+end

data/test/lib/spec/runner/heckle_runner_win.rb

@@ -0,0 +1,10 @@
+module Spec
+  module Runner
+    # Dummy implementation for Windows that just fails (Heckle is not supported on Windows)
+    class HeckleRunner
+      def initialize(filter)
+        raise "Heckle not supported on Windows"
+      end
+    end
+  end
+end

data/test/lib/spec/runner/option_parser.rb

@@ -0,0 +1,224 @@
+require 'ostruct'
+require 'optparse'
+require 'spec/runner/spec_parser'
+require 'spec/runner/formatter'
+require 'spec/runner/backtrace_tweaker'
+require 'spec/runner/reporter'
+require 'spec/runner/context_runner'
+
+module Spec
+  module Runner
+    class OptionParser
+      def initialize
+        @spec_parser = SpecParser.new
+        @file_factory = File
+      end
+
+      def create_context_runner(args, err, out, warn_if_no_files)
+        options = parse(args, err, out, warn_if_no_files)
+        # Some exit points in parse (--generate-options, --drb) don't return the options, 
+        # but hand over control. In that case we don't want to continue.
+        return nil unless options.is_a?(OpenStruct)
+
+        formatter = options.formatter_type.new(options.out, options.dry_run, options.colour)
+        options.reporter = Reporter.new(formatter, options.backtrace_tweaker) 
+
+        # this doesn't really belong here.
+        # it should, but the way things are coupled, it doesn't
+        if options.differ_class
+          Spec::Expectations.differ = options.differ_class.new(options.diff_format, options.context_lines, options.colour)
+        end
+
+        unless options.generate
+          ContextRunner.new(options)  
+        end
+      end
+
+      def parse(args, err, out, warn_if_no_files)
+        options_file = nil
+        args_copy = args.dup
+        options = OpenStruct.new
+        options.out = (out == STDOUT ? Kernel : out)
+        options.formatter_type = Formatter::ProgressBarFormatter
+        options.backtrace_tweaker = QuietBacktraceTweaker.new
+        options.spec_name = nil
+
+        opts = ::OptionParser.new do |opts|
+          opts.banner = "Usage: spec [options] (FILE|DIRECTORY|GLOB)+"
+          opts.separator ""
+
+          opts.on("-D", "--diff [FORMAT]", "Show diff of objects that are expected to be equal when they are not",
+                                           "Builtin formats: unified|u|context|c",
+                                           "You can also specify a custom differ class",
+                                           "(in which case you should also specify --require)") do |format|
+
+            # TODO make context_lines settable
+            options.context_lines = 3
+
+            case format
+              when 'context', 'c'
+                options.diff_format  = :context
+              when 'unified', 'u', '', nil
+                options.diff_format  = :unified
+            end
+
+            if [:context,:unified].include? options.diff_format
+              require 'spec/expectations/differs/default'
+              options.differ_class = Spec::Expectations::Differs::Default
+            else
+              begin
+                options.diff_format  = :custom
+                options.differ_class = eval(format)
+              rescue NameError
+                err.puts "Couldn't find differ class #{format}"
+                err.puts "Make sure the --require option is specified *before* --diff"
+                exit if out == $stdout
+              end
+            end
+
+          end
+          
+          opts.on("-c", "--colour", "--color", "Show coloured (red/green) output") do
+            options.colour = true
+          end
+          
+          opts.on("-s", "--spec SPECIFICATION_NAME", "Execute context or specification with matching name") do |spec_name|
+            options.spec_name = spec_name
+          end
+          
+          opts.on("-l", "--line LINE_NUMBER", Integer, "Execute context or specification at given line") do |line_number|
+            options.line_number = line_number.to_i
+          end
+
+          opts.on("-f", "--format FORMAT", "Builtin formats: specdoc|s|rdoc|r|html|h", 
+                                           "You can also specify a custom formatter class",
+                                           "(in which case you should also specify --require)") do |format|
+            case format
+              when 'specdoc', 's'
+                options.formatter_type = Formatter::SpecdocFormatter
+              when 'html', 'h'
+                options.formatter_type = Formatter::HtmlFormatter
+              when 'rdoc', 'r'
+                options.formatter_type = Formatter::RdocFormatter
+                options.dry_run = true
+            else
+              begin
+                options.formatter_type = eval(format)
+              rescue NameError
+                err.puts "Couldn't find formatter class #{format}"
+                err.puts "Make sure the --require option is specified *before* --format"
+                exit if out == $stdout
+              end
+            end
+          end
+
+          opts.on("-r", "--require FILE", "Require FILE before running specs",
+                                          "Useful for loading custom formatters or other extensions",
+                                          "If this option is used it must come before the others") do |req|
+            req.split(",").each{|file| require file}
+          end
+          
+          opts.on("-b", "--backtrace", "Output full backtrace") do
+            options.backtrace_tweaker = NoisyBacktraceTweaker.new
+          end
+
+          opts.on("-H", "--heckle CODE", "If all specs pass, this will run your specs many times, mutating",
+                                         "the specced code a little each time. The intent is that specs",
+                                         "*should* fail, and RSpec will tell you if they don't.",
+                                         "CODE should be either Some::Module, Some::Class or Some::Fabulous#method}") do |heckle|
+            heckle_runner = PLATFORM == 'i386-mswin32' ? 'spec/runner/heckle_runner_win' : 'spec/runner/heckle_runner'
+            require heckle_runner
+            options.heckle_runner = HeckleRunner.new(heckle)
+          end
+          
+          opts.on("-d", "--dry-run", "Don't execute specs") do
+            options.dry_run = true
+          end
+          
+          opts.on("-o", "--out OUTPUT_FILE", "Path to output file (defaults to STDOUT)") do |out_file|
+            options.out = File.new(out_file, 'w')
+          end
+          
+          opts.on("-O", "--options PATH", "Read options from a file") do |options_file|
+            # Remove the --options option and the argument before writing to file
+            index = args_copy.index("-O") || args_copy.index("--options")
+            args_copy.delete_at(index)
+            args_copy.delete_at(index)
+
+            new_args = args_copy + IO.readlines(options_file).each {|s| s.chomp!}
+            return CommandLine.run(new_args, err, out, true, warn_if_no_files)
+          end
+
+          opts.on("-G", "--generate-options PATH", "Generate an options file for --options") do |options_file|
+            # Remove the --generate-options option and the argument before writing to file
+            index = args_copy.index("-G") || args_copy.index("--generate-options")
+            args_copy.delete_at(index)
+            args_copy.delete_at(index)
+
+            File.open(options_file, 'w') do |io|
+              io.puts args_copy.join("\n")
+            end
+            out.puts "\nOptions written to #{options_file}. You can now use these options with:"
+            out.puts "spec --options #{options_file}"
+            options.generate = true
+          end
+          
+          opts.on("-X", "--drb", "Run specs via DRb. (For example against script/rails_spec_server)") do |options_file|
+            # Remove the --options option and the argument before writing to file
+            index = args_copy.index("-X") || args_copy.index("--drb")
+            args_copy.delete_at(index)
+
+            return DrbCommandLine.run(args_copy, err, out, true, warn_if_no_files)
+          end
+
+          opts.on("-v", "--version", "Show version") do
+            out.puts ::Spec::VERSION::DESCRIPTION
+            exit if out == $stdout
+          end
+
+          opts.on_tail("-h", "--help", "You're looking at it") do
+            out.puts opts
+            exit if out == $stdout
+          end
+          
+        end
+        opts.parse!(args)
+
+        if args.empty? && warn_if_no_files
+          err.puts "No files specified."
+          err.puts opts
+          exit(6) if err == $stderr
+        end
+
+        if options.line_number
+          set_spec_from_line_number(options, args, err)
+        end
+
+        options
+      end
+      
+      def set_spec_from_line_number(options, args, err)
+        unless options.spec_name
+          if args.length == 1
+            if @file_factory.file?(args[0])
+              source = @file_factory.open(args[0])
+              options.spec_name = @spec_parser.spec_name_for(source, options.line_number)
+            elsif @file_factory.directory?(args[0])
+              err.puts "You must specify one file, not a directory when using the --line option"
+              exit(1) if err == $stderr
+            else
+              err.puts "#{args[0]} does not exist"
+              exit(2) if err == $stderr
+            end
+          else
+            err.puts "Only one file can be specified when using the --line option: #{args.inspect}"
+            exit(3) if err == $stderr
+          end
+        else
+          err.puts "You cannot use both --line and --spec"
+          exit(4) if err == $stderr
+        end
+      end
+    end
+  end
+end

data/test/lib/spec/runner/reporter.rb

@@ -0,0 +1,105 @@
+module Spec
+  module Runner
+    class Reporter
+      
+      def initialize(formatter, backtrace_tweaker)
+        @formatter = formatter
+        @backtrace_tweaker = backtrace_tweaker
+        clear!
+      end
+      
+      def add_context(name)
+        #TODO - @context_names.empty? tells the formatter whether this is the first context or not - that's a little slippery
+        @formatter.add_context(name, @context_names.empty?)
+        @context_names << name
+      end
+      
+      def spec_started(name)
+        @spec_names << name
+        @formatter.spec_started(name)
+      end
+      
+      def spec_finished(name, error=nil, failure_location=nil)
+        if error.nil?
+          spec_passed(name)
+        else
+          @backtrace_tweaker.tweak_backtrace(error, failure_location)
+          spec_failed(name, Failure.new(@context_names.last, name, error))
+        end
+      end
+
+      def start(number_of_specs)
+        clear!
+        @start_time = Time.new
+        @formatter.start(number_of_specs)
+      end
+  
+      def end
+        @end_time = Time.new
+      end
+  
+      # Dumps the summary and returns the total number of failures
+      def dump
+        @formatter.start_dump
+        dump_failures
+        @formatter.dump_summary(duration, @spec_names.length, @failures.length)
+        @failures.length
+      end
+
+      private
+  
+      def clear!
+        @context_names = []
+        @failures = []
+        @spec_names = []
+        @start_time = nil
+        @end_time = nil
+      end
+  
+      def dump_failures
+        return if @failures.empty?
+        @failures.inject(1) do |index, failure|
+          @formatter.dump_failure(index, failure)
+          index + 1
+        end
+      end
+
+      def duration
+        return @end_time - @start_time unless (@end_time.nil? or @start_time.nil?)
+        return "0.0"
+      end
+
+      def spec_passed(name)
+        @formatter.spec_passed(name)
+      end
+
+      def spec_failed(name, failure)
+        @failures << failure
+        @formatter.spec_failed(name, @failures.length, failure)
+      end
+
+      class Failure
+        attr_reader :exception
+        
+        def initialize(context_name, spec_name, exception)
+          @context_name = context_name
+          @spec_name = spec_name
+          @exception = exception
+        end
+
+        def header
+          if expectation_not_met?
+            "'#{@context_name} #{@spec_name}' FAILED"
+          else
+            "#{@exception.class.name} in '#{@context_name} #{@spec_name}'"
+          end
+        end
+        
+        def expectation_not_met?
+          @exception.is_a?(Spec::Expectations::ExpectationNotMetError)
+        end
+
+      end
+    end
+  end
+end