puppet 0.23.2 → 0.24.0

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

@@ -1,140 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

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

@@ -1,41 +0,0 @@
-module Spec
-  module Matchers
-    
-    class Match #:nodoc:
-      def initialize(expected)
-        @expected = expected
-      end
-      
-      def matches?(actual)
-        @actual = actual
-        return true if actual =~ @expected
-        return false
-      end
-      
-      def failure_message
-        return "expected #{@actual.inspect} to match #{@expected.inspect}", @expected, @actual
-      end
-      
-      def negative_failure_message
-        return "expected #{@actual.inspect} not to match #{@expected.inspect}", @expected, @actual
-      end
-      
-      def description
-        "match #{@expected.inspect}"
-      end
-    end
-    
-    # :call-seq:
-    #   should match(regexp)
-    #   should_not match(regexp)
-    #
-    # Given a Regexp, passes if actual =~ regexp
-    #
-    # == Examples
-    #
-    #   email.should match(/^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
-    def match(regexp)
-      Matchers::Match.new(regexp)
-    end
-  end
-end

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

@@ -1,100 +0,0 @@
-module Spec
-  module Matchers
-    
-    class RaiseError #:nodoc:
-      def initialize(exception=Exception, message=nil)
-        @expected_error = exception
-        @expected_message = message
-      end
-      
-      def matches?(proc)
-        @raised_expected_error = false
-        @raised_other = false
-        begin
-          proc.call
-        rescue @expected_error => @actual_error
-          if @expected_message.nil?
-            @raised_expected_error = true
-          else
-            case @expected_message
-            when Regexp
-              if @expected_message =~ @actual_error.message
-                @raised_expected_error = true
-              else
-                @raised_other = true
-              end
-            else
-              if @actual_error.message == @expected_message
-                @raised_expected_error = true
-              else
-                @raised_other = true
-              end
-            end
-          end
-        rescue => @actual_error
-          @raised_other = true
-        ensure
-          return @raised_expected_error
-        end
-      end
-      
-      def failure_message
-        return "expected #{expected_error}#{actual_error}" if @raised_other || !@raised_expected_error
-      end
-
-      def negative_failure_message
-        "expected no #{expected_error}#{actual_error}"
-      end
-      
-      def description
-        "raise #{expected_error}"
-      end
-      
-      private
-        def expected_error
-          case @expected_message
-          when nil
-            @expected_error
-          when Regexp
-            "#{@expected_error} with message matching #{@expected_message.inspect}"
-          else
-            "#{@expected_error} with #{@expected_message.inspect}"
-          end
-        end
-
-        def actual_error
-          @actual_error.nil? ? " but nothing was raised" : ", got #{@actual_error.inspect}"
-        end
-    end
-    
-    # :call-seq:
-    #   should raise_error()
-    #   should raise_error(NamedError)
-    #   should raise_error(NamedError, String)
-    #   should raise_error(NamedError, Regexp)
-    #   should_not raise_error()
-    #   should_not raise_error(NamedError)
-    #   should_not raise_error(NamedError, String)
-    #   should_not raise_error(NamedError, Regexp)
-    #
-    # With no args, matches if any error is raised.
-    # With a named error, matches only if that specific error is raised.
-    # With a named error and messsage specified as a String, matches only if both match.
-    # With a named error and messsage specified as a Regexp, matches only if both match.
-    #
-    # == Examples
-    #
-    #   lambda { do_something_risky }.should raise_error
-    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError)
-    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError, "that was too risky")
-    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError, /oo ri/)
-    #
-    #   lambda { do_something_risky }.should_not raise_error
-    #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError)
-    #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError, "that was too risky")
-    #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError, /oo ri/)
-    def raise_error(error=Exception, message=nil)
-      Matchers::RaiseError.new(error, message)
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-module Spec
-  module Matchers
-    
-    class RespondTo #:nodoc:
-      def initialize(sym)
-        @sym = sym
-      end
-      
-      def matches?(target)
-        return target.respond_to?(@sym)
-      end
-      
-      def failure_message
-        "expected target to respond to #{@sym.inspect}"
-      end
-      
-      def negative_failure_message
-        "expected target not to respond to #{@sym.inspect}"
-      end
-      
-      def description
-        "respond to ##{@sym.to_s}"
-      end
-    end
-    
-    # :call-seq:
-    #   should respond_to(:sym)
-    #   should_not respond_to(:sym)
-    #
-    # Matches if the target object responds to :sym
-    def respond_to(sym)
-      Matchers::RespondTo.new(sym)
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-module Spec
-  module Matchers
-    
-    class Satisfy #:nodoc:
-      def initialize(&block)
-        @block = block
-      end
-      
-      def matches?(actual, &block)
-        @block = block if block
-        @actual = actual
-        @block.call(actual)
-      end
-      
-      def failure_message
-        "expected #{@actual} to satisfy block"
-      end
-
-      def negative_failure_message
-        "expected #{@actual} not to satisfy block"
-      end
-    end
-    
-    # :call-seq:
-    #   should satisfy {}
-    #   should_not satisfy {}
-    #
-    # Passes if the submitted block returns true. Yields target to the
-    # block.
-    #
-    # Generally speaking, this should be thought of as a last resort when
-    # you can't find any other way to specify the behaviour you wish to
-    # specify.
-    #
-    # If you do find yourself in such a situation, you could always write
-    # a custom matcher, which would likely make your specs more expressive.
-    #
-    # == Examples
-    #
-    #   5.should satisfy { |n|
-    #     n > 3
-    #   }
-    def satisfy(&block)
-      Matchers::Satisfy.new(&block)
-    end
-  end
-end

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

@@ -1,75 +0,0 @@
-module Spec
-  module Matchers
-    
-    class ThrowSymbol #:nodoc:
-      def initialize(expected=nil)
-        @expected = expected
-      end
-      
-      def matches?(proc)
-        begin
-          proc.call
-        rescue NameError => e
-          @actual = extract_sym_from_name_error(e)
-        ensure
-          if @expected.nil?
-            return @actual.nil? ? false : true
-          else
-            return @actual == @expected
-          end
-        end
-      end
-
-      def failure_message
-        if @actual
-          "expected #{expected}, got #{@actual.inspect}"
-        else
-          "expected #{expected} but nothing was thrown"
-        end
-      end
-      
-      def negative_failure_message
-        if @expected
-          "expected #{expected} not to be thrown"
-        else
-          "expected no Symbol, got :#{@actual}"
-        end
-      end
-      
-      def description
-        "throw #{expected}"
-      end
-      
-      private
-      
-        def expected
-          @expected.nil? ? "a Symbol" : @expected.inspect
-        end
-      
-        def extract_sym_from_name_error(error)
-          return "#{error.message.split("`").last.split("'").first}".to_sym
-        end
-    end
- 
-    # :call-seq:
-    #   should throw_symbol()
-    #   should throw_symbol(:sym)
-    #   should_not throw_symbol()
-    #   should_not throw_symbol(:sym)
-    #
-    # Given a Symbol argument, matches if a proc throws the specified Symbol.
-    #
-    # Given no argument, matches if a proc throws any Symbol.
-    #
-    # == Examples
-    #
-    #   lambda { do_something_risky }.should throw_symbol
-    #   lambda { do_something_risky }.should throw_symbol(:that_was_risky)
-    #
-    #   lambda { do_something_risky }.should_not throw_symbol
-    #   lambda { do_something_risky }.should_not throw_symbol(:that_was_risky)
-    def throw_symbol(sym=nil)
-      Matchers::ThrowSymbol.new(sym)
-    end
-  end
-end