puppet 4.2.3-x64-mingw32 → 4.3.0-x64-mingw32

data/spec/unit/functions4_spec.rb

@@ -74,11 +74,7 @@ describe 'the 4x function api' do
   it 'an error is raised when calling a no arguments function with arguments' do
     f = create_noargs_function_class()
     func = f.new(:closure_scope, :loader)
-    expect{func.call({}, 'surprise')}.to raise_error(ArgumentError, "function 'test' called with mis-matched arguments
-expected:
-  test() - arg count {0}
-actual:
-  test(String) - arg count {1}")
+    expect{func.call({}, 'surprise')}.to raise_error(ArgumentError, "'test' expects no arguments, got 1")
   end
 
   it 'a simple function can be called' do
@@ -97,11 +93,7 @@ actual:
     signature = 'Any x, Any y'
     expect do
       func.call({}, 10)
-    end.to raise_error(ArgumentError, "function 'min' called with mis-matched arguments
-expected:
-  min(#{signature}) - arg count {2}
-actual:
-  min(Integer) - arg count {1}")
+    end.to raise_error(ArgumentError, "'min' expects 2 arguments, got 1")
   end
 
   it 'an error is raised if called with too many arguments' do
@@ -112,12 +104,7 @@ actual:
     signature = 'Any x, Any y'
     expect do
       func.call({}, 10, 10, 10)
-    end.to raise_error(ArgumentError, Regexp.new(Regexp.escape(
-"function 'min' called with mis-matched arguments
-expected:
-  min(#{signature}) - arg count {2}
-actual:
-  min(Integer, Integer, Integer) - arg count {3}")))
+    end.to raise_error(ArgumentError, "'min' expects 2 arguments, got 3")
   end
 
   it 'an error is raised if simple function-name and method are not matched' do
@@ -151,44 +138,22 @@ actual:
       func = f.new(:closure_scope, :loader)
       expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
       expect do
-        func.call({}, 10, 10, 10)
-      end.to raise_error(ArgumentError, Regexp.new(Regexp.escape(
-"function 'min' called with mis-matched arguments
-expected:
-  min(Numeric a, Numeric b) - arg count {2}
-actual:
-  min(Integer, Integer, Integer) - arg count {3}")))
+        func.call({}, 10, 'ten')
+      end.to raise_error(ArgumentError, "'min' parameter 'b' expects a Numeric value, got String")
     end
 
-    it 'an error includes optional indicators and count for last element' do
-      f = create_function_with_optionals_and_varargs()
+    it 'an error includes optional indicators for last element' do
+      f = create_function_with_optionals_and_repeated_via_multiple_dispatch()
       # TODO: Bogus parameters, not yet used
       func = f.new(:closure_scope, :loader)
       expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
-      signature = 'Any x, Any y, Any a?, Any b?, Any c{0,}'
       expect do
-        func.call({}, 10)
-      end.to raise_error(ArgumentError,
-"function 'min' called with mis-matched arguments
-expected:
-  min(#{signature}) - arg count {2,}
-actual:
-  min(Integer) - arg count {1}")
-    end
-
-    it 'an error includes optional indicators and count for last element when defined via dispatch' do
-      f = create_function_with_optionals_and_repeated_via_dispatch()
-      # TODO: Bogus parameters, not yet used
-      func = f.new(:closure_scope, :loader)
-      expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
-      expect do
-        func.call({}, 10)
-      end.to raise_error(ArgumentError,
-"function 'min' called with mis-matched arguments
-expected:
-  min(Numeric x, Numeric y, Numeric a?, Numeric b?, Numeric c{0,}) - arg count {2,}
-actual:
-  min(Integer) - arg count {1}")
+        func.call({}, 3, 10, 3, "4")
+      end.to raise_error(ArgumentError, "'min' expected one of:
+  (Numeric x, Numeric y, Numeric a?, Numeric b?, Numeric c*)
+    rejected: parameter 'b' expects a Numeric value, got String
+  (String x, String y, String a+)
+    rejected: parameter 'x' expects a String value, got Integer")
     end
 
     it 'can create optional repeated parameter' do
@@ -210,12 +175,7 @@ actual:
       func = f.new(:closure_scope, :loader)
       expect(func.call({}, 1)).to eql(1)
       expect(func.call({}, 1, 2)).to eql(2)
-      expect { func.call({}) }.to raise_error(ArgumentError,
-"function 'count_args' called with mis-matched arguments
-expected:
-  count_args(Any c{1,}) - arg count {1,}
-actual:
-  count_args(Undef{0}) - arg count {0}")
+      expect { func.call({}) }.to raise_error(ArgumentError, "'count_args' expects at least 1 argument, got none")
     end
 
     it 'can create scope_param followed by repeated  parameter' do
@@ -256,14 +216,12 @@ actual:
       func = f.new(:closure_scope, :loader)
       expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
       expect do
-        func.call({}, 10, 10, 10)
-      end.to raise_error(ArgumentError,
-"function 'min' called with mis-matched arguments
-expected one of:
-  min(Numeric a, Numeric b) - arg count {2}
-  min(String s1, String s2) - arg count {2}
-actual:
-  min(Integer, Integer, Integer) - arg count {3}")
+        func.call({}, 10, '20')
+      end.to raise_error(ArgumentError, "'min' expected one of:
+  (Numeric a, Numeric b)
+    rejected: parameter 'b' expects a Numeric value, got String
+  (String s1, String s2)
+    rejected: parameter 's1' expects a String value, got Integer")
     end
 
     context 'can use injection' do
@@ -334,12 +292,7 @@ actual:
         the_function = create_function_with_required_block_all_defaults().new(:closure_scope, :loader)
         expect do
           the_function.call({}, 10)
-        end.to raise_error(ArgumentError,
-"function 'test' called with mis-matched arguments
-expected:
-  test(Integer x, Callable block) - arg count {2}
-actual:
-  test(Integer) - arg count {1}")
+        end.to raise_error(ArgumentError, "'test' expects a block")
       end
 
       it 'such that, an optional block can be defined and given as an argument' do
@@ -361,7 +314,7 @@ actual:
 
     context 'provides signature information' do
       it 'about capture rest (varargs)' do
-        fc = create_function_with_optionals_and_varargs
+        fc = create_function_with_optionals_and_repeated
         signatures = fc.signatures
         expect(signatures.size).to eql(1)
         signature = signatures[0]
@@ -369,14 +322,14 @@ actual:
       end
 
       it 'about optional and required parameters' do
-        fc = create_function_with_optionals_and_varargs
+        fc = create_function_with_optionals_and_repeated
         signature = fc.signatures[0]
         expect(signature.args_range).to eql( [2, Float::INFINITY ] )
         expect(signature.infinity?(signature.args_range[1])).to be_truthy
       end
 
       it 'about block not being allowed' do
-        fc = create_function_with_optionals_and_varargs
+        fc = create_function_with_optionals_and_repeated
         signature = fc.signatures[0]
         expect(signature.block_range).to eql( [ 0, 0 ] )
         expect(signature.block_type).to be_nil
@@ -582,7 +535,7 @@ actual:
     end
   end
 
-  def create_function_with_optionals_and_varargs
+  def create_function_with_optionals_and_repeated
     f = Puppet::Functions.create_function('min') do
       def min(x,y,a=1, b=1, *c)
         x <= y ? x : y
@@ -605,6 +558,39 @@ actual:
     end
   end
 
+  def create_function_with_optionals_and_repeated_via_multiple_dispatch
+    f = Puppet::Functions.create_function('min') do
+      dispatch :min do
+        param 'Numeric', :x
+        param 'Numeric', :y
+        optional_param 'Numeric', :a
+        optional_param 'Numeric', :b
+        repeated_param 'Numeric', :c
+      end
+      dispatch :min do
+        param 'String', :x
+        param 'String', :y
+        required_repeated_param 'String', :a
+      end
+      def min(x,y,a=1, b=1, *c)
+        x <= y ? x : y
+      end
+    end
+  end
+
+  def create_function_with_required_repeated_via_dispatch
+    f = Puppet::Functions.create_function('min') do
+      dispatch :min do
+        param 'Numeric', :x
+        param 'Numeric', :y
+        required_repeated_param 'Numeric', :z
+      end
+      def min(x,y, *z)
+        x <= y ? x : y
+      end
+    end
+  end
+
   def create_function_with_repeated
     f = Puppet::Functions.create_function('count_args') do
       dispatch :count_args do

data/spec/unit/indirector/catalog/compiler_spec.rb

@@ -46,7 +46,7 @@ describe Puppet::Resource::Catalog::Compiler do
 
     it "should directly use provided nodes for a local request" do
       Puppet::Node.indirection.expects(:find).never
-      @compiler.expects(:compile).with(@node)
+      @compiler.expects(:compile).with(@node, nil)
       @request.stubs(:options).returns(:use_node => @node)
       @request.stubs(:remote?).returns(false)
       @compiler.find(@request)
@@ -63,7 +63,7 @@ describe Puppet::Resource::Catalog::Compiler do
     it "should use the authenticated node name if no request key is provided" do
       @request.stubs(:key).returns(nil)
       Puppet::Node.indirection.expects(:find).with(@name, anything).returns(@node)
-      @compiler.expects(:compile).with(@node)
+      @compiler.expects(:compile).with(@node, nil)
       @compiler.find(@request)
     end
 
@@ -71,7 +71,7 @@ describe Puppet::Resource::Catalog::Compiler do
       @request.expects(:key).returns "my_node"
 
       Puppet::Node.indirection.expects(:find).with("my_node", anything).returns @node
-      @compiler.expects(:compile).with(@node)
+      @compiler.expects(:compile).with(@node, nil)
       @compiler.find(@request)
     end
 
@@ -88,7 +88,7 @@ describe Puppet::Resource::Catalog::Compiler do
     it "should pass the found node to the compiler for compiling" do
       Puppet::Node.indirection.expects(:find).with(@name, anything).returns(@node)
       config = mock 'config'
-      Puppet::Parser::Compiler.expects(:compile).with(@node)
+      Puppet::Parser::Compiler.expects(:compile).with(@node, nil)
       @compiler.find(@request)
     end
 
@@ -119,11 +119,31 @@ describe Puppet::Resource::Catalog::Compiler do
 
     it "should return the results of compiling as the catalog" do
       Puppet::Node.indirection.stubs(:find).returns(@node)
-      config = mock 'config'
-      result = mock 'result'
+      catalog = Puppet::Resource::Catalog.new(@node.name)
+      Puppet::Parser::Compiler.stubs(:compile).returns catalog
+
+      expect(@compiler.find(@request)).to equal(catalog)
+    end
+
+    it "passes the code_id from the request to the compiler" do
+      Puppet::Node.indirection.stubs(:find).returns(@node)
+      code_id = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
+      @request.options[:code_id] = code_id
+
+      Puppet::Parser::Compiler.expects(:compile).with(anything, code_id)
+
+      @compiler.find(@request)
+    end
+
+    it "returns a catalog with the code_id from the request" do
+      Puppet::Node.indirection.stubs(:find).returns(@node)
+      code_id = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
+      @request.options[:code_id] = code_id
+
+      catalog = Puppet::Resource::Catalog.new(@node.name, @node.environment, code_id)
+      Puppet::Parser::Compiler.stubs(:compile).returns catalog
 
-      Puppet::Parser::Compiler.expects(:compile).returns result
-      expect(@compiler.find(@request)).to equal(result)
+      expect(@compiler.find(@request).code_id).to eq(code_id)
     end
   end
 

data/spec/unit/indirector/catalog/static_compiler_spec.rb

@@ -34,6 +34,10 @@ describe Puppet::Resource::Catalog::StaticCompiler do
   end
 
   describe "#find" do
+    before :each do
+      subject.stubs(:store_content)
+    end
+
     it "returns a catalog" do
       expect(subject.find(request)).to be_a_kind_of(Puppet::Resource::Catalog)
     end
@@ -45,7 +49,8 @@ describe Puppet::Resource::Catalog::StaticCompiler do
 
     describe "a catalog with file resources containing source parameters with puppet:// URIs" do
       it "filters file resource source URI's to checksums" do
-        stub_the_compiler
+        subject.stubs(:compile).returns(build_catalog)
+
         resource_catalog = subject.find(request)
         resource_catalog.resources.each do |resource|
           next unless resource.type == "File"
@@ -56,7 +61,8 @@ describe Puppet::Resource::Catalog::StaticCompiler do
 
       it "does not modify file resources with non-puppet:// URI's" do
         uri = "/this/is/not/a/puppet/uri.txt"
-        stub_the_compiler(:source => uri)
+        subject.stubs(:compile).returns(build_catalog(:source => uri))
+
         resource_catalog = subject.find(request)
         resource_catalog.resources.each do |resource|
           next unless resource.type == "File"
@@ -65,16 +71,41 @@ describe Puppet::Resource::Catalog::StaticCompiler do
         end
       end
 
-      it "copies the owner, group and mode from the fileserer" do
-        stub_the_compiler
+      it "copies the owner, group and mode from the fileserver" do
+        subject.stubs(:compile).returns(build_catalog)
+
         resource_catalog = subject.find(request)
         resource_catalog.resources.each do |resource|
           next unless resource.type == "File"
-          expect(resource[:owner]).to eq(0)
-          expect(resource[:group]).to eq(0)
-          expect(resource[:mode]).to  eq(420)
+          expect(resource[:owner]).to eq("0")
+          expect(resource[:group]).to eq("0")
+          expect(resource[:mode]).to  eq("644")
         end
       end
+
+      it "ignores recurse when source refers to a file" do
+        path = File.expand_path('/tmp/foo')
+        metadata = fileserver_metadata(:path => path)
+        metadata.relative_path = '.'
+
+        Puppet::FileServing::Metadata.indirection.stubs(:search).returns([metadata])
+        Puppet::FileServing::Metadata.indirection.stubs(:find).returns(metadata)
+
+        catalog = Puppet::Resource::Catalog.new(request)
+        catalog.add_resource(
+          Puppet::Resource.new('file', path,
+            :parameters => {
+              :recurse => true,
+              :source => 'puppet:///modules/mymodule/foo'
+            }
+          )
+        )
+        subject.stubs(:compile).returns(catalog)
+
+        resource = subject.find(request).resources.first
+        expect(resource[:ensure]).to eq('file')
+        expect(resource.title).to eq(path)
+      end
     end
   end
 
@@ -120,19 +151,6 @@ describe Puppet::Resource::Catalog::StaticCompiler do
 
   # Spec helper methods
 
-  def stub_the_compiler(options = {:stub_methods => [:store_content]})
-    # Build a resource catalog suitable for specifying the behavior of the
-    # static compiler.
-    compiler = mock('indirection terminus compiler')
-    compiler.stubs(:find).returns(build_catalog(options))
-    subject.stubs(:compiler).returns(compiler)
-    # Mock the store content method to prevent copying the contents to the
-    # file bucket.
-    (options[:stub_methods] || []).each do |mthd|
-      subject.stubs(mthd)
-    end
-  end
-
   def build_catalog(options = {})
     options = options.dup
     options[:source] ||= 'puppet:///modules/mymodule/config_file.txt'

data/spec/unit/indirector/data_binding/none_spec.rb

@@ -20,9 +20,9 @@ describe Puppet::DataBinding::None do
   end
 
   describe "the behavior of the find method" do
-    it "should just return nil" do
+    it "should just throw :no_such_key" do
       data_binding = Puppet::DataBinding::None.new
-      expect(data_binding.find('fake_request')).to be_nil
+      expect { data_binding.find('fake_request') }.to throw_symbol(:no_such_key)
     end
   end
 end

data/spec/unit/indirector/file_bucket_file/file_spec.rb

@@ -109,6 +109,57 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         let(:not_bucketed_plaintext) { "other stuff" }
         let(:not_bucketed_checksum) { digest(not_bucketed_plaintext) }
 
+        describe "when listing the filebucket" do
+          it "should return false/nil when the bucket is empty" do
+            expect(Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar", :list_all => true)).to eq(nil)
+          end
+
+          it "raises when the request is remote" do
+            Puppet[:bucketdir] = tmpdir('bucket')
+
+            request = Puppet::Indirector::Request.new(:file_bucket_file, :find, "#{digest_algorithm}/#{checksum}/foo/bar", nil, :list_all => true)
+            request.node = 'client.example.com'
+
+            expect {
+              Puppet::FileBucketFile::File.new.find(request)
+            }.to raise_error(Puppet::Error, "Listing remote file buckets is not allowed")
+          end
+
+          it "should return the list of bucketed files in a human readable way" do
+            checksum1 = save_bucket_file("I'm the contents of a file", '/foo/bar1')
+            checksum2 = save_bucket_file("I'm the contents of another file", '/foo/bar2')
+            checksum3 = save_bucket_file("I'm the modified content of a existing file", '/foo/bar1')
+
+            # Use the first checksum as we know it's stored in the bucket
+            find_result = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum1}/foo/bar1", :list_all => true)
+
+            # The list is sort order from date and file name, so first and third checksums come before the second
+            date_pattern = '\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'
+            expect(find_result.to_s).to match(Regexp.new("^#{checksum1} #{date_pattern} foo/bar1\\n#{checksum3} #{date_pattern} foo/bar1\\n#{checksum2} #{date_pattern} foo/bar2\\n$"))
+          end
+
+          it "should fail in an informative way when provided dates are not in the right format" do
+            contents = "I'm the contents of a file"
+            save_bucket_file(contents, '/foo/bar1')
+            expect {
+              Puppet::FileBucket::File.indirection.find(
+                "#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar",
+                :list_all => true,
+                :todate => "0:0:0 1-1-1970",
+                :fromdate => "WEIRD"
+              )
+            }.to raise_error(Puppet::Error, /fromdate/)
+            expect {
+              Puppet::FileBucket::File.indirection.find(
+                "#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar",
+                :list_all => true,
+                :todate => "WEIRD",
+                :fromdate => Time.now
+              )
+            }.to raise_error(Puppet::Error, /todate/)
+          end
+        end
+
         describe "when supplying a path" do
           it "should return false/nil if the file isn't bucketed" do
             expect(Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar")).to eq(false)
@@ -177,7 +228,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
           checksum2 = save_bucket_file("foo\nbiz\nbaz")
 
           diff = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum1}", :diff_with => checksum2)
-          expect(diff).to eq("2c2\n< bar\n---\n> biz\n")
+          expect(diff).to include("-bar\n+biz\n")
         end
 
         it "should raise an exception if the hash to diff against isn't found" do