puppet 0.23.2 → 0.24.0

data/test/language/snippets.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'puppet'
 require 'puppet/parser/interpreter'
@@ -11,7 +11,6 @@ require 'puppettest'
 
 class TestSnippets < Test::Unit::TestCase
 	include PuppetTest
-    include ObjectSpace
 
     def setup
         super
@@ -198,12 +197,12 @@ class TestSnippets < Test::Unit::TestCase
     def snippet_classpathtest
         path = "/tmp/classtest"
 
-        file = @file[path]
+        file = @catalog.resource(:file, path)
         assert(file, "did not create file %s" % path)
 
         assert_nothing_raised {
             assert_equal(
-                "//testing/component[componentname]/File[/tmp/classtest]",
+                "//testing/Mytype[componentname]/File[/tmp/classtest]",
                 file.path)
         }
     end
@@ -272,14 +271,6 @@ class TestSnippets < Test::Unit::TestCase
         assert_mode_equal(0755, file)
     end
 
-    def snippet_failmissingexecpath
-        file = "/tmp/exectesting1"
-        execfile = "/tmp/execdisttesting"
-        assert_file(file)
-
-        assert_nil(Puppet::Type.type(:exec)["exectest"], "invalid exec was created")
-    end
-
     def snippet_selectorvalues
         nums = %w{1 2 3 4 5}
         files = nums.collect { |n|
@@ -458,35 +449,25 @@ class TestSnippets < Test::Unit::TestCase
             #eval("alias %s %s" % [testname, mname])
             testname = ("test_" + mname).intern
             self.send(:define_method, testname) {
-                # first parse the file
-                server = Puppet::Network::Handler.master.new(
-                    :Manifest => snippet(file),
-                    :Local => true
-                )
-                client = Puppet::Network::Client.master.new(
-                    :Master => server,
-                    :Cache => false
-                )
-
-                assert(client.local)
-                assert_nothing_raised {
-                    client.getconfig()
+                Puppet[:manifest] = snippet(file)
+                facts = {
+                    "hostname" => "testhost",
+                    "domain" => "domain.com",
+                    "ipaddress" => "127.0.0.1",
+                    "fqdn" => "testhost.domain.com"
                 }
 
-                client = Puppet::Network::Client.master.new(
-                    :Master => server,
-                    :Cache => false
-                )
+                node = Puppet::Node.new("testhost")
+                node.merge(facts)
 
-                assert(client.local)
-                # Now do it again
-                Puppet::Type.allclear
-                assert_nothing_raised {
-                    client.getconfig()
+                catalog = nil
+                assert_nothing_raised("Could not compile catalog") {
+                    catalog = Puppet::Node::Catalog.find(node)
+                }
+
+                assert_nothing_raised("Could not convert catalog") {
+                    catalog = catalog.to_ral
                 }
-                #assert_nothing_raised {
-                #    trans = client.apply()
-                #}
 
                 Puppet::Type.eachtype { |type|
                     type.each { |obj|
@@ -498,15 +479,12 @@ class TestSnippets < Test::Unit::TestCase
                         assert(obj.name)
                     }
                 }
+                @catalog = catalog
                 assert_nothing_raised {
                     self.send(mname)
                 }
-
-                client.clear
             }
             mname = mname.intern
         end
     }
 end
-
-# $Id: snippets.rb 2463 2007-05-04 23:09:34Z luke $

data/test/language/transportable.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'puppet'
 require 'puppet/transportable'
@@ -47,37 +47,17 @@ class TestTransportable < Test::Unit::TestCase
         assert(newobj.type, "Bucket has no type")
     end
 
-    # Verify that we correctly strip out collectable objects, since they should
-    # not be sent to the client.
-    def test_collectstrip
-        top = mk_transtree do |object, depth, width|
-            if width % 2 == 1
-                object.collectable = true
-            end
-        end
-
-        assert(top.flatten.find_all { |o| o.collectable }.length > 0,
-            "Could not find any collectable objects")
-
-        # Now strip out the collectable objects
-        top.collectstrip!
-
-        # And make sure they're actually gone
-        assert_equal(0, top.flatten.find_all { |o| o.collectable }.length,
-            "Still found collectable objects")
-    end
-
     # Make sure our 'delve' command is working
     def test_delve
         top = mk_transtree do |object, depth, width|
             if width % 2 == 1
-                object.collectable = true
+                object.file = :funtest
             end
         end
 
         objects = []
         buckets = []
-        collectable = []
+        found = []
 
         count = 0
         assert_nothing_raised {
@@ -87,8 +67,8 @@ class TestTransportable < Test::Unit::TestCase
                     buckets << object
                 else
                     objects << object
-                    if object.collectable
-                        collectable << object
+                    if object.file == :funtest
+                        found << object
                     end
                 end
             end
@@ -98,10 +78,9 @@ class TestTransportable < Test::Unit::TestCase
             assert(objects.include?(obj), "Missing obj %s[%s]" % [obj.type, obj.name])
         end
 
-        assert_equal(collectable.length,
-            top.flatten.find_all { |o| o.collectable }.length,
-            "Found incorrect number of collectable objects")
+        assert_equal(found.length,
+            top.flatten.find_all { |o| o.file == :funtest }.length,
+            "Found incorrect number of objects")
     end
 end
 
-# $Id: transportable.rb 1793 2006-10-16 22:01:40Z luke $

data/test/lib/mocha/auto_verify.rb

@@ -1,12 +1,12 @@
 require 'mocha/mock'
 
-# Methods added to TestCase allowing creation of mock objects.
-#
-# Mocks created this way will have their expectations automatically verified at the end of the test.
-#
-# See Mocha::MockMethods for methods on mock objects.
-module Mocha
+module Mocha # :nodoc:
   
+  # Methods added to TestCase allowing creation of traditional mock objects.
+  #
+  # Mocks created this way will have their expectations automatically verified at the end of the test.
+  #
+  # See Mock for methods on mock objects.
   module AutoVerify
   
     def mocks # :nodoc:

data/test/lib/mocha/deprecation.rb

@@ -0,0 +1,22 @@
+module Mocha
+  
+  class Deprecation
+    
+    class << self
+      
+      attr_accessor :mode, :messages
+      
+      def warning(message)
+        @messages << message
+        $stderr.puts "Mocha deprecation warning: #{message}" unless mode == :disabled
+        $stderr.puts caller.join("\n  ") if mode == :debug
+      end
+
+    end
+  
+    self.mode = :enabled
+    self.messages = []
+    
+  end
+   
+end

data/test/lib/mocha/exception_raiser.rb

@@ -0,0 +1,17 @@
+module Mocha # :nodoc:
+  
+  class ExceptionRaiser # :nodoc:
+    
+    def initialize(exception, message)
+      @exception, @message = exception, message
+    end
+    
+    def evaluate
+      raise @exception, @exception.to_s if @exception == Interrupt
+      raise @exception, @message if @message
+      raise @exception
+    end
+    
+  end
+  
+end

data/test/lib/mocha/expectation.rb

@@ -1,21 +1,18 @@
 require 'mocha/infinite_range'
 require 'mocha/pretty_parameters'
 require 'mocha/expectation_error'
+require 'mocha/return_values'
+require 'mocha/exception_raiser'
+require 'mocha/yield_parameters'
+require 'mocha/is_a'
 
-class Object
-
-  alias_method :__is_a__, :is_a?
-
-end
-
-module Mocha
-  # Methods on expectations returned from Mocha::MockMethods#expects and Mocha::MockMethods#stubs
+module Mocha # :nodoc:
+  
+  # Methods on expectations returned from Mock#expects, Mock#stubs, Object#expects and Object#stubs.
   class Expectation
   
     # :stopdoc:
     
-    class InvalidExpectation < Exception; end
-    
     class AlwaysEqual
       def ==(other)
         true
@@ -26,23 +23,26 @@ module Mocha
 
     def initialize(mock, method_name, backtrace = nil)
       @mock, @method_name = mock, method_name
-      @count = 1
+      @expected_count = 1
       @parameters, @parameter_block = AlwaysEqual.new, nil
-      @invoked, @return_value = 0, nil
+      @invoked_count, @return_values = 0, ReturnValues.new
       @backtrace = backtrace || caller
-      @yield = nil
+      @yield_parameters = YieldParameters.new
     end
     
-    def yield?
-      @yield
-    end
-
     def match?(method_name, *arguments)
+      return false unless @method_name == method_name
       if @parameter_block then
-        @parameter_block.call(*arguments)
+        return false unless @parameter_block.call(*arguments)
+      else
+        return false unless (@parameters == arguments)
+      end
+      if @expected_count.is_a?(Range) then
+        return false unless @invoked_count < @expected_count.last
       else
-        (@method_name == method_name) and (@parameters == arguments)
+        return false unless @invoked_count < @expected_count
       end
+      return true
     end
 
     # :startdoc:
@@ -54,34 +54,63 @@ module Mocha
     # +range+ can be specified as an exact integer or as a range of integers
     #   object = mock()
     #   object.expects(:expected_method).times(3)
-    #   3.times { object.expected_method } # => verify succeeds
+    #   3.times { object.expected_method }
+    #   # => verify succeeds
     #
     #   object = mock()
     #   object.expects(:expected_method).times(3)
-    #   2.times { object.expected_method } # => verify fails
+    #   2.times { object.expected_method }
+    #   # => verify fails
     #
     #   object = mock()
     #   object.expects(:expected_method).times(2..4)
-    #   3.times { object.expected_method } # => verify succeeds
+    #   3.times { object.expected_method }
+    #   # => verify succeeds
     #
     #   object = mock()
     #   object.expects(:expected_method).times(2..4)
-    #   object.expected_method # => verify fails
+    #   object.expected_method
+    #   # => verify fails
     def times(range)
-      @count = range
+      @expected_count = range
+      self
+    end
+  
+    # :call-seq: once() -> expectation
+    #
+    # Modifies expectation so that the expected method must be called exactly once.
+    # Note that this is the default behaviour for an expectation, but you may wish to use it for clarity/emphasis.
+    #   object = mock()
+    #   object.expects(:expected_method).once
+    #   object.expected_method
+    #   # => verify succeeds
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).once
+    #   object.expected_method
+    #   object.expected_method
+    #   # => verify fails
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).once
+    #   # => verify fails
+    def once()
+      times(1)
       self
     end
   
-    # :call-seq: never -> expectation
+    # :call-seq: never() -> expectation
     #
     # Modifies expectation so that the expected method must never be called.
     #   object = mock()
     #   object.expects(:expected_method).never
-    #   object.expected_method # => verify fails
+    #   object.expected_method
+    #   # => verify fails
     #
     #   object = mock()
     #   object.expects(:expected_method).never
-    #   object.expected_method # => verify succeeds
+    #   object.expected_method
+    #   # => verify succeeds
     def never
       times(0)
       self
@@ -92,11 +121,13 @@ module Mocha
     # Modifies expectation so that the expected method must be called at least a +minimum_number_of_times+.
     #   object = mock()
     #   object.expects(:expected_method).at_least(2)
-    #   3.times { object.expected_method } # => verify succeeds
+    #   3.times { object.expected_method }
+    #   # => verify succeeds
     #
     #   object = mock()
     #   object.expects(:expected_method).at_least(2)
-    #   object.expected_method # => verify fails
+    #   object.expected_method
+    #   # => verify fails
     def at_least(minimum_number_of_times)
       times(Range.at_least(minimum_number_of_times))
       self
@@ -107,7 +138,8 @@ module Mocha
     # Modifies expectation so that the expected method must be called at least once.
     #   object = mock()
     #   object.expects(:expected_method).at_least_once
-    #   object.expected_method # => verify succeeds
+    #   object.expected_method
+    #   # => verify succeeds
     #
     #   object = mock()
     #   object.expects(:expected_method).at_least_once
@@ -122,11 +154,13 @@ module Mocha
     # Modifies expectation so that the expected method must be called at most a +maximum_number_of_times+.
     #   object = mock()
     #   object.expects(:expected_method).at_most(2)
-    #   2.times { object.expected_method } # => verify succeeds
+    #   2.times { object.expected_method }
+    #   # => verify succeeds
     #
     #   object = mock()
     #   object.expects(:expected_method).at_most(2)
-    #   3.times { object.expected_method } # => verify fails
+    #   3.times { object.expected_method }
+    #   # => verify fails
     def at_most(maximum_number_of_times)
       times(Range.at_most(maximum_number_of_times))
       self
@@ -137,11 +171,13 @@ module Mocha
     # Modifies expectation so that the expected method must be called at most once.
     #   object = mock()
     #   object.expects(:expected_method).at_most_once
-    #   object.expected_method # => verify succeeds
+    #   object.expected_method
+    #   # => verify succeeds
     #
     #   object = mock()
     #   object.expects(:expected_method).at_most_once
-    #   2.times { object.expected_method } # => verify fails
+    #   2.times { object.expected_method }
+    #   # => verify fails
     def at_most_once()
       at_most(1)
       self
@@ -152,20 +188,26 @@ module Mocha
     # Modifies expectation so that the expected method must be called with specified +arguments+.
     #   object = mock()
     #   object.expects(:expected_method).with(:param1, :param2)
-    #   object.expected_method(:param1, :param2) # => verify succeeds
+    #   object.expected_method(:param1, :param2)
+    #   # => verify succeeds
     #
     #   object = mock()
     #   object.expects(:expected_method).with(:param1, :param2)
-    #   object.expected_method(:param3) # => verify fails
+    #   object.expected_method(:param3)
+    #   # => verify fails
+    # May be used with parameter matchers in Mocha::ParameterMatchers.
+    #
     # If a +parameter_block+ is given, the block is called with the parameters passed to the expected method.
     # The expectation is matched if the block evaluates to +true+.
     #   object = mock()
     #   object.expects(:expected_method).with() { |value| value % 4 == 0 }
-    #   object.expected_method(16) # => verify succeeds
+    #   object.expected_method(16)
+    #   # => verify succeeds
     #
     #   object = mock()
     #   object.expects(:expected_method).with() { |value| value % 4 == 0 }
-    #   object.expected_method(17) # => verify fails
+    #   object.expected_method(17)
+    #   # => verify fails
     def with(*arguments, &parameter_block)
       @parameters, @parameter_block = arguments, parameter_block
       class << @parameters; def to_s; join(', '); end; end
@@ -180,12 +222,42 @@ module Mocha
     #   yielded_value = nil
     #   object.expected_method { |value| yielded_value = value }
     #   yielded_value # => 'result'
+    # May be called multiple times on the same expectation for consecutive invocations. Also see Expectation#then.
+    #   object = mock()
+    #   object.stubs(:expected_method).yields(1).then.yields(2)
+    #   yielded_values_from_first_invocation = []
+    #   yielded_values_from_second_invocation = []
+    #   object.expected_method { |value| yielded_values_from_first_invocation << value } # first invocation
+    #   object.expected_method { |value| yielded_values_from_second_invocation << value } # second invocation
+    #   yielded_values_from_first_invocation # => [1]
+    #   yielded_values_from_second_invocation # => [2]
     def yields(*parameters)
-      @yield = true
-      @parameters_to_yield = parameters
+      @yield_parameters.add(*parameters)
       self
     end
-
+    
+    # :call-seq: multiple_yields(*parameter_groups) -> expectation
+    #
+    # Modifies expectation so that when the expected method is called, it yields multiple times per invocation with the specified +parameter_groups+.
+    #   object = mock()
+    #   object.expects(:expected_method).multiple_yields(['result_1', 'result_2'], ['result_3'])
+    #   yielded_values = []
+    #   object.expected_method { |*values| yielded_values << values }
+    #   yielded_values # => [['result_1', 'result_2'], ['result_3]]
+    # May be called multiple times on the same expectation for consecutive invocations. Also see Expectation#then.
+    #   object = mock()
+    #   object.stubs(:expected_method).multiple_yields([1, 2], [3]).then.multiple_yields([4], [5, 6])
+    #   yielded_values_from_first_invocation = []
+    #   yielded_values_from_second_invocation = []
+    #   object.expected_method { |*values| yielded_values_from_first_invocation << values } # first invocation
+    #   object.expected_method { |*values| yielded_values_from_second_invocation << values } # second invocation
+    #   yielded_values_from_first_invocation # => [[1, 2], [3]]
+    #   yielded_values_from_second_invocation # => [[4], [5, 6]]
+    def multiple_yields(*parameter_groups)
+      @yield_parameters.multiple_add(*parameter_groups)
+      self
+    end
+    
     # :call-seq: returns(value) -> expectation
     # :call-seq: returns(*values) -> expectation
     #
@@ -199,13 +271,30 @@ module Mocha
     #   object.stubs(:stubbed_method).returns(1, 2)
     #   object.stubbed_method # => 1
     #   object.stubbed_method # => 2
-    # If +value+ is a Proc, then expected method will return result of calling Proc.
+    # May be called multiple times on the same expectation. Also see Expectation#then.
+    #   object = mock()
+    #   object.stubs(:expected_method).returns(1, 2).then.returns(3)
+    #   object.expected_method # => 1
+    #   object.expected_method # => 2
+    #   object.expected_method # => 3
+    # May be called in conjunction with Expectation#raises on the same expectation.
+    #   object = mock()
+    #   object.stubs(:expected_method).returns(1, 2).then.raises(Exception)
+    #   object.expected_method # => 1
+    #   object.expected_method # => 2
+    #   object.expected_method # => raises exception of class Exception1
+    # If +value+ is a +Proc+, then the expected method will return the result of calling <tt>Proc#call</tt>.
+    #
+    # This usage is _deprecated_.
+    # Use explicit multiple return values and/or multiple expectations instead.
+    #
+    # A +Proc+ instance will be treated the same as any other value in a future release.
     #   object = mock()
     #   object.stubs(:stubbed_method).returns(lambda { rand(100) })
     #   object.stubbed_method # => 41
     #   object.stubbed_method # => 77
     def returns(*values)
-      @return_value = (values.size > 1) ? lambda { values.shift } : @return_value = values.first
+      @return_values += ReturnValues.build(*values)
       self
     end
   
@@ -215,23 +304,51 @@ module Mocha
     #   object = mock()
     #   object.expects(:expected_method).raises(Exception, 'message')
     #   object.expected_method # => raises exception of class Exception and with message 'message'
+    # May be called multiple times on the same expectation. Also see Expectation#then.
+    #   object = mock()
+    #   object.stubs(:expected_method).raises(Exception1).then.raises(Exception2)
+    #   object.expected_method # => raises exception of class Exception1
+    #   object.expected_method # => raises exception of class Exception2
+    # May be called in conjunction with Expectation#returns on the same expectation.
+    #   object = mock()
+    #   object.stubs(:expected_method).raises(Exception).then.returns(2, 3)
+    #   object.expected_method # => raises exception of class Exception1
+    #   object.expected_method # => 2
+    #   object.expected_method # => 3
     def raises(exception = RuntimeError, message = nil)
-      @return_value = message ? lambda { raise exception, message } : lambda { raise exception }
+      @return_values += ReturnValues.new(ExceptionRaiser.new(exception, message))
       self
     end
 
+    # :call-seq: then() -> expectation
+    #
+    # Syntactic sugar to improve readability. Has no effect on state of the expectation.
+    #   object = mock()
+    #   object.stubs(:expected_method).returns(1, 2).then.raises(Exception).then.returns(4)
+    #   object.expected_method # => 1
+    #   object.expected_method # => 2
+    #   object.expected_method # => raises exception of class Exception
+    #   object.expected_method # => 4
+    def then
+      self
+    end
+    
     # :stopdoc:
     
     def invoke
-      @invoked += 1
-      yield(*@parameters_to_yield) if yield? and block_given?
-      @return_value.__is_a__(Proc) ? @return_value.call : @return_value
+      @invoked_count += 1
+      if block_given? then
+        @yield_parameters.next_invocation.each do |yield_parameters|
+          yield(*yield_parameters)
+        end
+      end
+      @return_values.next
     end
 
     def verify
       yield(self) if block_given?
-      unless (@count === @invoked) then
-        error = ExpectationError.new(error_message(@count, @invoked))
+      unless (@expected_count === @invoked_count) then
+        error = ExpectationError.new(error_message(@expected_count, @invoked_count))
         error.set_backtrace(filtered_backtrace)
         raise error
       end
@@ -251,45 +368,11 @@ module Mocha
     end
     
     def error_message(expected_count, actual_count)
-      "#{@mock.mocha_inspect}.#{method_signature} - expected calls: #{expected_count}, actual calls: #{actual_count}"
+      "#{@mock.mocha_inspect}.#{method_signature} - expected calls: #{expected_count.mocha_inspect}, actual calls: #{actual_count}"
     end
   
     # :startdoc:
     
   end
 
-  # :stopdoc:
-  
-  class Stub < Expectation
-  
-    def verify
-      true
-    end
-  
-  end
-
-  class MissingExpectation < Expectation
-  
-    def initialize(mock, method_name)
-      super
-      @invoked = true
-    end
-  
-    def verify
-      msg = error_message(0, 1)
-      similar_expectations_list = similar_expectations.collect { |expectation| expectation.method_signature }.join("\n")
-      msg << "\nSimilar expectations:\n#{similar_expectations_list}" unless similar_expectations.empty?
-      error = ExpectationError.new(msg)
-      error.set_backtrace(filtered_backtrace)
-      raise error if @invoked
-    end
-  
-    def similar_expectations
-      @mock.expectations.select { |expectation| expectation.method_name == self.method_name }
-    end
-  
-  end
-
-  # :startdoc:
-  
 end