puppet 0.18.4 → 0.22.4

data/test/lib/spec/expectations/should/should.rb

@@ -0,0 +1,81 @@
+module Spec
+  module Expectations
+    module Should # :nodoc:
+
+      class Should < Base
+
+        def initialize(target, expectation=nil)
+          @target = target
+          @be_seen = false
+        end
+        
+        deprecated do
+          #Gone for 0.9
+          def not
+            Not.new(@target)
+          end
+            
+          #Gone for 0.9
+          def be(expected = :___no_arg)
+            @be_seen = true
+            return self if (expected == :___no_arg)
+            if Symbol === expected
+              fail_with_message(default_message("should be", expected)) unless (@target.equal?(expected))
+            else
+              fail_with_message("expected #{expected}, got #{@target} (using .equal?)") unless (@target.equal?(expected))
+            end
+          end
+        
+          #Gone for 0.9
+          def have(expected_number=nil)
+            Have.new(@target, :exactly, expected_number)
+          end
+
+          #Gone for 0.9
+          def change(receiver=nil, message=nil, &block)
+            Change.new(@target, receiver, message, &block)
+          end
+
+          #Gone for 0.9
+          def raise(exception=Exception, message=nil)
+            begin
+              @target.call
+            rescue exception => e
+              unless message.nil?
+                if message.is_a?(Regexp)
+                  e.message.should =~ message
+                else
+                  e.message.should == message
+                end
+              end
+              return
+            rescue => e
+              fail_with_message("expected #{exception}#{message.nil? ? "" : " with #{message.inspect}"}, got #{e.inspect}")
+            end
+            fail_with_message("expected #{exception}#{message.nil? ? "" : " with #{message.inspect}"} but nothing was raised")
+          end
+  
+          #Gone for 0.9
+          def throw(symbol)
+            begin
+              catch symbol do
+                @target.call
+                fail_with_message("expected #{symbol.inspect} to be thrown, but nothing was thrown")
+              end
+            rescue NameError => e
+              fail_with_message("expected #{symbol.inspect} to be thrown, got #{e.inspect}")
+            end
+          end
+        end
+
+        private
+        def __delegate_method_missing_to_target(original_sym, actual_sym, *args)
+          ::Spec::Matchers.generated_description = "should #{original_sym} #{args[0].inspect}"
+          return if @target.send(actual_sym, *args)
+          fail_with_message(default_message(original_sym, args[0]), args[0], @target)
+        end
+      end
+
+    end
+  end
+end

data/test/lib/spec/expectations/sugar.rb

@@ -0,0 +1,47 @@
+deprecated do
+module Spec
+  module Expectations
+    # This module adds syntactic sugar that allows usage of should_* instead of should.*
+    module UnderscoreSugar
+      def handle_underscores_for_rspec!  # :nodoc:
+        original_method_missing = instance_method(:method_missing)
+        class_eval do
+          def method_missing(sym, *args, &block)
+            _method_missing(sym, args, block)
+          end
+
+          define_method :_method_missing do |sym, args, block|
+            return original_method_missing.bind(self).call(sym, *args, &block) unless sym.to_s =~ /^should_/
+            if sym.to_s =~ /^should_not_/
+              if __matcher.respond_to?(__strip_should_not(sym))
+                return should_not(__matcher.__send__(__strip_should_not(sym), *args, &block))
+              else
+                return Spec::Expectations::Should::Not.new(self).__send__(__strip_should_not(sym), *args, &block) if sym.to_s =~ /^should_not_/
+              end
+            else
+              if __matcher.respond_to?(__strip_should(sym))
+                return should(__matcher.__send__(__strip_should(sym), *args, &block))
+              else
+                return Spec::Expectations::Should::Should.new(self).__send__(__strip_should(sym), *args, &block)
+              end
+            end
+          end
+          
+          def __strip_should(sym) # :nodoc
+            sym.to_s[7..-1]
+          end
+          
+          def __strip_should_not(sym) # :nodoc
+            sym.to_s[11..-1]
+          end
+          
+          def __matcher
+            @matcher ||= Spec::Matchers::Matcher.new
+          end
+        end
+      end
+    end
+  end
+end
+
+end

data/test/lib/spec/matchers.rb

@@ -0,0 +1,160 @@
+require 'spec/deprecated'
+require 'spec/callback'
+require 'spec/matchers/be'
+require 'spec/matchers/be_close'
+require 'spec/matchers/change'
+require 'spec/matchers/eql'
+require 'spec/matchers/equal'
+require 'spec/matchers/has'
+require 'spec/matchers/have'
+require 'spec/matchers/include'
+require 'spec/matchers/match'
+require 'spec/matchers/raise_error'
+require 'spec/matchers/respond_to'
+require 'spec/matchers/satisfy'
+require 'spec/matchers/throw_symbol'
+
+module Spec
+
+  # RSpec ships with a number of useful Expression Matchers. An Expression Matcher
+  # is any object that responds to the following methods:
+  #
+  #   matches?(actual)
+  #   failure_message
+  #   negative_failure_message #optional
+  #   description #optional
+  #
+  # See Spec::Expectations to learn how to use these as Expectation Matchers.
+  # See Spec::Mocks to learn how to use them as Mock Argument Constraints.
+  #
+  # == Predicates
+  #
+  # In addition to those Expression Matchers that are defined explicitly, RSpec will
+  # create custom Matchers on the fly for any arbitrary predicate, giving your specs
+  # a much more natural language feel. 
+  #
+  # A Ruby predicate is a method that ends with a "?" and returns true or false.
+  # Common examples are +empty?+, +nil?+, and +instance_of?+.
+  #
+  # All you need to do is write +should be_+ followed by the predicate without
+  # the question mark, and RSpec will figure it out from there. For example:
+  #
+  #   [].should be_empty => [].empty? #passes
+  #   [].should_not be_empty => [].empty? #fails
+  #
+  # In addtion to prefixing the predicate matchers with "be_", you can also use "be_a_"
+  # and "be_an_", making your specs read much more naturally:
+  #
+  #   "a string".should be_an_instance_of(String) =>"a string".instance_of?(String) #passes
+  #
+  #   3.should be_a_kind_of(Fixnum) => 3.kind_of?(Numeric) #passes
+  #   3.should be_a_kind_of(Numeric) => 3.kind_of?(Numeric) #passes
+  #   3.should be_an_instance_of(Fixnum) => 3.instance_of?(Fixnum) #passes
+  #   3.should_not be_instance_of(Numeric) => 3.instance_of?(Numeric) #fails
+  #
+  # RSpec will also create custom matchers for predicates like +has_key?+. To
+  # use this feature, just state that the object should have_key(:key) and RSpec will
+  # call has_key?(:key) on the target. For example:
+  #
+  #   {:a => "A"}.should have_key(:a) => {:a => "A"}.has_key?(:a) #passes
+  #   {:a => "A"}.should have_key(:b) => {:a => "A"}.has_key?(:b) #fails
+  #
+  # You can use this feature to invoke any predicate that begins with "has_", whether it is
+  # part of the Ruby libraries (like +Hash#has_key?+) or a method you wrote on your own class.
+  #
+  # == Custom Expression Matchers
+  #
+  # When you find that none of the stock Expression Matchers provide a natural
+  # feeling expectation, you can very easily write your own.
+  #
+  # For example, imagine that you are writing a game in which players can
+  # be in various zones on a virtual board. To specify that bob should
+  # be in zone 4, you could say:
+  #
+  #   bob.current_zone.should eql(Zone.new("4"))
+  #
+  # But you might find it more expressive to say:
+  #
+  #   bob.should be_in_zone("4")
+  #
+  # and/or
+  #
+  #   bob.should_not be_in_zone("3")
+  #
+  # To do this, you would need to write a class like this:
+  #
+  #   class BeInZone
+  #     def initialize(expected)
+  #       @expected = expected
+  #     end
+  #     def matches?(actual)
+  #       @actual = actual
+  #       bob.current_zone.eql?(Zone.new(@expected))
+  #     end
+  #     def failure_message
+  #       "expected #{@actual.inspect} to be in Zone #{@expected}"
+  #     end
+  #     def negative_failure_message
+  #       "expected #{@actual.inspect} not to be in Zone #{@expected}"
+  #     end
+  #   end
+  #
+  # ... and a method like this:
+  #
+  #   def be_in_zone(expected)
+  #     BeInZone.new(expected)
+  #   end
+  #
+  # And then expose the method to your specs. This is normally done
+  # by including the method and the class in a module, which is then
+  # included in your spec:
+  #
+  #   module CustomGameMatchers
+  #     class BeInZone
+  #       ...
+  #     end
+  #
+  #     def be_in_zone(expected)
+  #       ...
+  #     end
+  #   end
+  #
+  #   context "Player behaviour" do
+  #     include CustomGameMatchers
+  #     ...
+  #   end
+  module Matchers
+    
+    class << self
+      callback_events :description_generated
+      def generated_description=(name)
+        notify_callbacks(:description_generated, name)
+      end
+    end
+    
+    def method_missing(sym, *args, &block) # :nodoc:
+      return Matchers::Be.new(sym, *args) if sym.starts_with?("be_")
+      return Matchers::Has.new(sym, *args) if sym.starts_with?("have_")
+      super
+    end
+
+    deprecated do
+      # This supports sugar delegating to Matchers
+      class Matcher #:nodoc:
+        include Matchers
+
+        def respond_to?(sym)
+          if sym.to_s[0..2] == "be_"
+            return true
+          else
+            super
+          end
+        end
+      end
+    end
+    
+    class MatcherError < StandardError
+    end
+    
+  end
+end

data/test/lib/spec/matchers/be.rb

@@ -0,0 +1,161 @@
+module Spec
+  module Matchers
+    
+    class Be #:nodoc:
+      def initialize(expected=nil, *args)
+        @expected = parse_expected(expected)
+        @args = args
+        @comparison = ""
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        return true if match_or_compare unless handling_predicate?
+        if handling_predicate?
+          begin
+            return @result = actual.__send__(predicate, *@args)
+          rescue => predicate_error
+            # This clause should be empty, but rcov will not report it as covered
+            # unless something (anything) is executed within the clause
+            rcov_error_report = "http://eigenclass.org/hiki.rb?rcov-0.8.0"
+          end
+
+          # This supports should_exist > target.exists? in the old world.
+          # We should consider deprecating that ability as in the new world
+          # you can't write "should exist" unless you have your own custom matcher.
+          begin
+            return @result = actual.__send__(present_tense_predicate, *@args)
+          rescue
+            raise predicate_error
+          end
+        end
+        return false
+      end
+      
+      def failure_message
+        return "expected #{@comparison}#{expected}, got #{@actual.inspect}" unless handling_predicate?
+        return "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}"
+      end
+      
+      def negative_failure_message
+        return "expected not #{expected}, got #{@actual.inspect}" unless handling_predicate?
+        return "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}"
+      end
+      
+      def expected
+        return true if @expected == :true
+        return false if @expected == :false
+        return "nil" if @expected == :nil
+        return @expected.inspect
+      end
+      
+      def match_or_compare
+        return @actual == true if @expected == :true
+        return @actual == false if @expected == :false
+        return @actual.nil? if @expected == :nil
+        return @actual < @expected if @less_than
+        return @actual <= @expected if @less_than_or_equal
+        return @actual >= @expected if @greater_than_or_equal
+        return @actual > @expected if @greater_than
+        return @actual.equal?(@expected)
+      end
+
+      def <(expected)
+        @less_than = true
+        @comparison = "< "
+        @expected = expected
+        self
+      end
+
+      def <=(expected)
+        @less_than_or_equal = true
+        @comparison = "<= "
+        @expected = expected
+        self
+      end
+
+      def >=(expected)
+        @greater_than_or_equal = true
+        @comparison = ">= "
+        @expected = expected
+        self
+      end
+
+      def >(expected)
+        @greater_than = true
+        @comparison = "> "
+        @expected = expected
+        self
+      end
+      
+      def description
+        "be #{@comparison}#{@expected}"
+      end
+
+      private
+        def parse_expected(expected)
+          if Symbol === expected
+            ["be_an_","be_a_","be_"].each do |prefix|
+              @handling_predicate = true
+              return "#{expected.to_s.sub(prefix,"")}".to_sym if expected.starts_with?(prefix)
+            end
+          end
+          return expected
+        end
+
+        def predicate
+          "#{@expected.to_s}?".to_sym
+        end
+        
+        def present_tense_predicate
+          "#{@expected.to_s}s?".to_sym
+        end
+        
+        def args_to_s
+          return "" if @args.empty?
+          transformed_args = @args.collect{|a| a.inspect}
+          return "(#{transformed_args.join(', ')})"
+        end
+        
+        def handling_predicate?
+          return false if [:true, :false, :nil].include?(@expected)
+          return @handling_predicate
+        end
+    end
+ 
+    # :call-seq:
+    #   should be_true
+    #   should be_false
+    #   should be_nil
+    #   should be_arbitrary_predicate(*args)
+    #   should_not be_nil
+    #   should_not be_arbitrary_predicate(*args)
+    #
+    # Given true, false, or nil, will pass if actual is
+    # true, false or nil (respectively).
+    #
+    # Predicates are any Ruby method that ends in a "?" and returns true or false.
+    # Given be_ followed by arbitrary_predicate (without the "?"), RSpec will match
+    # convert that into a query against the target object.
+    #
+    # The arbitrary_predicate feature will handle any predicate
+    # prefixed with "be_an_" (e.g. be_an_instance_of), "be_a_" (e.g. be_a_kind_of)
+    # or "be_" (e.g. be_empty), letting you choose the prefix that best suits the predicate.
+    #
+    # == Examples 
+    #
+    #   target.should be_true
+    #   target.should be_false
+    #   target.should be_nil
+    #   target.should_not be_nil
+    #
+    #   collection.should be_empty #passes if target.empty?
+    #   "this string".should be_an_intance_of(String)
+    #
+    #   target.should_not be_empty #passes unless target.empty?
+    #   target.should_not be_old_enough(16) #passes unless target.old_enough?(16)
+    def be(*args)
+      Matchers::Be.new(*args)
+    end
+  end
+end