puppet 0.18.4 → 0.22.4

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

@@ -0,0 +1,37 @@
+module Spec
+  module Matchers
+
+    class BeClose #:nodoc:
+      def initialize(expected, delta)
+        @expected = expected
+        @delta = delta
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        (@actual - @expected).abs < @delta
+      end
+      
+      def failure_message
+        "expected #{@expected} +/- (<#{@delta}), got #{@actual}"
+      end
+      
+      def description
+        "be close to #{@expected} (+- #{@delta})"
+      end
+    end
+    
+    # :call-seq:
+    #   should be_close(expected, delta)
+    #   should_not be_close(expected, delta)
+    #
+    # Passes if actual == expected +/- delta
+    #
+    # == Example
+    #
+    #   result.should be_close(3.0, 0.5)
+    def be_close(expected, delta)
+      Matchers::BeClose.new(expected, delta)
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+module Spec
+  module Matchers
+    
+    #Based on patch from Wilson Bilkovich
+    class Change #:nodoc:
+      def initialize(receiver=nil, message=nil, &block)
+        @receiver = receiver
+        @message = message
+        @block = block
+      end
+      
+      def matches?(target, &block)
+        if block
+          raise MatcherError.new(<<-EOF
+block passed to should or should_not change must use {} instead of do/end
+EOF
+)
+        end
+        @target = target
+        execute_change
+        return false if @from && (@from != @before)
+        return false if @to && (@to != @after)
+        return (@before + @amount == @after) if @amount
+        return @before != @after
+      end
+      
+      def execute_change
+        @before = @block.nil? ? @receiver.send(@message) : @block.call
+        @target.call
+        @after = @block.nil? ? @receiver.send(@message) : @block.call
+      end
+      
+      def failure_message
+        if @to
+          "#{result} should have been changed to #{@to.inspect}, but is now #{@after.inspect}"
+        elsif @from
+          "#{result} should have initially been #{@from.inspect}, but was #{@before.inspect}"
+        elsif @amount
+          "#{result} should have been changed by #{@amount.inspect}, but was changed by #{actual_delta.inspect}"
+        else
+          "#{result} should have changed, but is still #{@before.inspect}"
+        end
+      end
+      
+      def result
+        @message || "result"
+      end
+      
+      def actual_delta
+        @after - @before
+      end
+      
+      def negative_failure_message
+        "#{result} should not have changed, but did change from #{@before.inspect} to #{@after.inspect}"
+      end
+      
+      def by(amount)
+        @amount = amount
+        self
+      end
+      
+      def to(to)
+        @to = to
+        self
+      end
+      
+      def from (from)
+        @from = from
+        self
+      end
+    end
+    
+    # :call-seq:
+    #   should change(receiver, message, &block)
+    #   should change(receiver, message, &block).by(value)
+    #   should change(receiver, message, &block).from(old).to(new)
+    #   should_not change(receiver, message, &block)
+    #
+    # Allows you to specify that a Proc will cause some value to change.
+    #
+    # == Examples
+    #
+    #   lambda {
+    #     team.add_player(player) 
+    #   }.should change(roster, :count)
+    #
+    #   lambda {
+    #     team.add_player(player) 
+    #   }.should change(roster, :count).by(1)
+    #
+    #   string = "string"
+    #   lambda {
+    #     string.reverse
+    #   }.should change { string }.from("string").to("gnirts")
+    #
+    #   lambda {
+    #     person.happy_birthday
+    #   }.should change(person, :birthday).from(32).to(33)
+    #       
+    #   lambda {
+    #     employee.develop_great_new_social_networking_app
+    #   }.should change(employee, :title).from("Mail Clerk").to("CEO")
+    #
+    # Evaluates +receiver.message+ or +block+ before and
+    # after it evaluates the c object (generated by the lambdas in the examples above).
+    #
+    # Then compares the values before and after the +receiver.message+ and
+    # evaluates the difference compared to the expected difference.
+    #
+    # == Warning
+    # +should_not+ +change+ only supports the form with no subsequent calls to
+    # +be+, +to+ or +from+.
+    #
+    # blocks passed to +should+ +change+ and +should_not+ +change+
+    # must use the <tt>{}</tt> form (<tt>do/end</tt> is not supported)
+    def change(target=nil, message=nil, &block)
+      Matchers::Change.new(target, message, &block)
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Spec
+  module Matchers
+  
+    class Eql #:nodoc:
+      def initialize(expected)
+        @expected = expected
+      end
+  
+      def matches?(actual)
+        @actual = actual
+        @actual.eql?(@expected)
+      end
+
+      def failure_message
+        return "expected #{@expected.inspect}, got #{@actual.inspect} (using .eql?)", @expected, @actual
+      end
+      
+      def negative_failure_message
+        return "expected #{@actual.inspect} not to equal #{@expected.inspect} (using .eql?)", @expected, @actual
+      end
+
+      def description
+        "eql #{@expected.inspect}"
+      end
+    end
+    
+    # :call-seq:
+    #   should eql(expected)
+    #   should_not eql(expected)
+    #
+    # Passes if actual and expected are of equal value, but not necessarily the same object.
+    #
+    # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
+    #
+    # == Examples
+    #
+    #   5.should eql(5)
+    #   5.should_not eql(3)
+    def eql(expected)
+      Matchers::Eql.new(expected)
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Spec
+  module Matchers
+  
+    class Equal #:nodoc:
+      def initialize(expected)
+        @expected = expected
+      end
+  
+      def matches?(actual)
+        @actual = actual
+        @actual.equal?(@expected)
+      end
+
+      def failure_message
+        return "expected #{@expected.inspect}, got #{@actual.inspect} (using .equal?)", @expected, @actual
+      end
+
+      def negative_failure_message
+        return "expected #{@actual.inspect} not to equal #{@expected.inspect} (using .equal?)", @expected, @actual
+      end
+      
+      def description
+        "equal #{@expected.inspect}"
+      end
+    end
+    
+    # :call-seq:
+    #   should equal(expected)
+    #   should_not equal(expected)
+    #
+    # Passes if actual and expected are the same object (object identity).
+    #
+    # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
+    #
+    # == Examples
+    #
+    #   5.should equal(5) #Fixnums are equal
+    #   "5".should_not equal("5") #Strings that look the same are not the same object
+    def equal(expected)
+      Matchers::Equal.new(expected)
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Spec
+  module Matchers
+    
+    class Has #:nodoc:
+      def initialize(sym, *args)
+        @sym = sym
+        @args = args
+      end
+      
+      def matches?(target)
+        @target = target
+        begin
+          return target.send(predicate, *@args)
+        rescue => @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
+        return false
+      end
+      
+      def failure_message
+        raise @error if @error
+        "expected ##{predicate}(#{@args[0].inspect}) to return true, got false"
+      end
+      
+      def negative_failure_message
+        raise @error if @error
+        "expected ##{predicate}(#{@args[0].inspect}) to return false, got true"
+      end
+      
+      def description
+        "have key #{@args[0].inspect}"
+      end
+      
+      private
+        def predicate
+          "#{@sym.to_s.sub("have_","has_")}?".to_sym
+        end
+        
+    end
+ 
+  end
+end

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

@@ -0,0 +1,140 @@
+module Spec
+  module Matchers
+    
+    class Have #:nodoc:
+      def initialize(expected, relativity=:exactly)
+        @expected = (expected == :no ? 0 : expected)
+        @relativity = relativity
+      end
+    
+      def relativities
+        @relativities ||= {
+          :exactly => "",
+          :at_least => "at least ",
+          :at_most => "at most "
+        }
+      end
+    
+      def method_missing(sym, *args, &block)
+        @collection_name = sym
+        @args = args
+        @block = block
+        self
+      end
+    
+      def matches?(collection_owner)
+        if collection_owner.respond_to?(collection_name)
+          collection = collection_owner.send(collection_name, *@args, &@block)
+        elsif (collection_owner.respond_to?(:length) || collection_owner.respond_to?(:size))
+          collection = collection_owner
+        else
+          collection_owner.send(collection_name, *@args, &@block)
+        end
+        @actual = collection.length if collection.respond_to?(:length)
+        @actual = collection.size if collection.respond_to?(:size)
+        return @actual >= @expected if @relativity == :at_least
+        return @actual <= @expected if @relativity == :at_most
+        return @actual == @expected
+      end
+    
+      def failure_message
+        "expected #{relative_expectation} #{collection_name}, got #{@actual}"
+      end
+
+      def negative_failure_message
+        if @relativity == :exactly
+          return "expected target not to have #{@expected} #{collection_name}, got #{@actual}"
+        elsif @relativity == :at_most
+          return <<-EOF
+Isn't life confusing enough?
+Instead of having to figure out the meaning of this:
+  should_not have_at_most(#{@expected}).#{collection_name}
+We recommend that you use this instead:
+  should have_at_least(#{@expected + 1}).#{collection_name}
+EOF
+        elsif @relativity == :at_least
+          return <<-EOF
+Isn't life confusing enough?
+Instead of having to figure out the meaning of this:
+  should_not have_at_least(#{@expected}).#{collection_name}
+We recommend that you use this instead:
+  should have_at_most(#{@expected - 1}).#{collection_name}
+EOF
+        end
+      end
+      
+      def description
+        "have #{relative_expectation} #{collection_name}"
+      end
+      
+      private
+      def collection_name
+        @collection_name
+      end
+      
+      def relative_expectation
+        "#{relativities[@relativity]}#{@expected}"
+      end
+    end
+
+    # :call-seq:
+    #   should have(number).named_collection__or__sugar
+    #   should_not have(number).named_collection__or__sugar
+    #
+    # Passes if receiver is a collection with the submitted
+    # number of items OR if the receiver OWNS a collection
+    # with the submitted number of items.
+    #
+    # If the receiver OWNS the collection, you must use the name
+    # of the collection. So if a <tt>Team</tt> instance has a
+    # collection named <tt>#players</tt>, you must use that name
+    # to set the expectation.
+    #
+    # If the receiver IS the collection, you can use any name
+    # you like for <tt>named_collection</tt>. We'd recommend using
+    # either "elements", "members", or "items" as these are all
+    # standard ways of describing the things IN a collection.
+    #
+    # This also works for Strings, letting you set an expectation
+    # about its length
+    #
+    # == Examples
+    #
+    #   # Passes if team.players.size == 11
+    #   team.should have(11).players
+    #
+    #   # Passes if [1,2,3].length == 3
+    #   [1,2,3].should have(3).items #"items" is pure sugar
+    #
+    #   # Passes if "this string".length == 11
+    #   "this string".should have(11).characters #"characters" is pure sugar
+    def have(n)
+      Matchers::Have.new(n)
+    end
+    alias :have_exactly :have
+
+    # :call-seq:
+    #   should have_at_least(number).items
+    #
+    # Exactly like have() with >=.
+    #
+    # == Warning
+    #
+    # +should_not+ +have_at_least+ is not supported
+    def have_at_least(n)
+      Matchers::Have.new(n, :at_least)
+    end
+
+    # :call-seq:
+    #   should have_at_most(number).items
+    #
+    # Exactly like have() with <=.
+    #
+    # == Warning
+    #
+    # +should_not+ +have_at_most+ is not supported
+    def have_at_most(n)
+      Matchers::Have.new(n, :at_most)
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Spec
+  module Matchers
+
+    class Include #:nodoc:
+      
+      def initialize(expected)
+        @expected = expected
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        actual.include?(@expected)
+      end
+      
+      def failure_message
+        _message
+      end
+      
+      def negative_failure_message
+        _message("not ")
+      end
+      
+      def description
+        "include #{@expected.inspect}"
+      end
+      
+      private
+        def _message(maybe_not="")
+          "expected #{@actual.inspect} #{maybe_not}to include #{@expected.inspect}"
+        end
+    end
+
+    # :call-seq:
+    #   should include(expected)
+    #   should_not include(expected)
+    #
+    # Passes if actual includes expected. This works for
+    # collections and Strings
+    #
+    # == Examples
+    #
+    #   [1,2,3].should include(3)
+    #   [1,2,3].should_not include(4)
+    #   "spread".should include("read")
+    #   "spread".should_not include("red")
+    def include(expected)
+      Matchers::Include.new(expected)
+    end
+  end
+end