puppet 4.5.3-x86-mingw32 → 4.6.1-x86-mingw32

data/spec/unit/module_spec.rb

@@ -614,13 +614,6 @@ describe Puppet::Module do
     expect(@module).to be_has_metadata
   end
 
-  it "should have metadata if it has a metadata file and its data is not empty" do
-    Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
-    File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns "{\"foo\" : \"bar\"}"
-
-    expect(@module).to be_has_metadata
-  end
-
   it "should not have metadata if has a metadata file and its data is empty" do
     Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
     File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns "This is some invalid json.\n"
@@ -651,6 +644,49 @@ describe Puppet::Module do
     expect(@module.has_metadata?).to be_falsey
   end
 
+  describe 'when --strict is warning' do
+    before :each do
+      Puppet[:strict] = :warning
+    end
+
+    it "should warn about a failure to parse" do
+      Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
+      File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
+
+      expect(@module.has_metadata?).to be_falsey
+      expect(@logs).to have_matching_log(/mymod has an invalid and unparsable metadata\.json file/)
+    end
+  end
+
+    describe 'when --strict is off' do
+      before :each do
+        Puppet[:strict] = :off
+      end
+
+      it "should warn about a failure to parse" do
+        Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
+        File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
+
+        expect(@module.has_metadata?).to be_falsey
+        expect(@logs).to have_matching_log(/mymod has an invalid and unparsable metadata\.json file.*/)
+      end
+    end
+
+    describe 'when --strict is error' do
+      before :each do
+        Puppet[:strict] = :error
+      end
+
+      it "should fail on a failure to parse" do
+        Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
+        File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
+
+        expect do
+        expect(@module.has_metadata?).to be_falsey
+        end.to raise_error(/mymod has an invalid and unparsable metadata\.json file/)
+      end
+    end
+
   def a_module_with_metadata(data)
     text = data.to_pson
 

data/spec/unit/module_tool/applications/installer_spec.rb

@@ -4,6 +4,8 @@ require 'puppet_spec/module_tool/shared_functions'
 require 'puppet_spec/module_tool/stub_source'
 require 'semver'
 
+require 'tmpdir'
+
 describe Puppet::ModuleTool::Applications::Installer do
   include PuppetSpec::ModuleTool::SharedFunctions
   include PuppetSpec::Files
@@ -32,6 +34,13 @@ describe Puppet::ModuleTool::Applications::Installer do
     installer.stubs(:module_repository).returns(remote_source)
   end
 
+  if Puppet.features.microsoft_windows?
+    before :each do
+      Puppet.settings.stubs(:[])
+      Puppet.settings.stubs(:[]).with(:module_working_dir).returns(Dir.mktmpdir('installertmp'))
+    end
+  end
+
   def installer(modname, target_dir, options)
     Puppet::ModuleTool.set_option_defaults(options)
     Puppet::ModuleTool::Applications::Installer.new(modname, target_dir, options)
@@ -358,6 +367,6 @@ describe Puppet::ModuleTool::Applications::Installer do
         end
       end
     end
-
   end
+
 end

data/spec/unit/module_tool/applications/unpacker_spec.rb

@@ -14,7 +14,8 @@ describe Puppet::ModuleTool::Applications::Unpacker do
   let(:working_dir) { tmpdir("working_dir") }
 
   before :each do
-    Puppet.settings[:module_working_dir] = working_dir
+    Puppet.settings.stubs(:[])
+    Puppet.settings.stubs(:[]).with(:module_working_dir).returns(working_dir)
   end
 
   it "should attempt to untar file to temporary location" do

data/spec/unit/module_tool/applications/upgrader_spec.rb

@@ -3,6 +3,7 @@ require 'puppet/module_tool/applications'
 require 'puppet_spec/module_tool/shared_functions'
 require 'puppet_spec/module_tool/stub_source'
 require 'semver'
+require 'tmpdir'
 
 describe Puppet::ModuleTool::Applications::Upgrader do
   include PuppetSpec::ModuleTool::SharedFunctions
@@ -31,6 +32,13 @@ describe Puppet::ModuleTool::Applications::Upgrader do
     installer.stubs(:module_repository).returns(remote_source)
   end
 
+  if Puppet.features.microsoft_windows?
+    before :each do
+      Puppet.settings.stubs(:[])
+      Puppet.settings.stubs(:[]).with(:module_working_dir).returns(Dir.mktmpdir('upgradertmp'))
+    end
+  end
+
   def upgrader(name, options = {})
     Puppet::ModuleTool.set_option_defaults(options)
     Puppet::ModuleTool::Applications::Upgrader.new(name, options)

data/spec/unit/module_tool/tar/mini_spec.rb

@@ -20,7 +20,7 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
     expect {
       minitar.unpack(sourcefile, destdir, 'uid')
     }.to raise_error(Puppet::ModuleTool::Errors::InvalidPathInPackageError,
-                     "Attempt to install file into \"/thefile\" under \"#{destdir}\"")
+                     "Attempt to install file with an invalid path into \"/thefile\" under \"#{destdir}\"")
   end
 
   it "does not allow a file to be written outside the destination directory" do
@@ -29,7 +29,7 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
     expect {
       minitar.unpack(sourcefile, destdir, 'uid')
     }.to raise_error(Puppet::ModuleTool::Errors::InvalidPathInPackageError,
-                     "Attempt to install file into \"#{File.expand_path('/the/thefile')}\" under \"#{destdir}\"")
+                     "Attempt to install file with an invalid path into \"#{File.expand_path('/the/thefile')}\" under \"#{destdir}\"")
   end
 
   it "does not allow a directory to be written outside the destination directory" do
@@ -38,7 +38,7 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
     expect {
       minitar.unpack(sourcefile, destdir, 'uid')
     }.to raise_error(Puppet::ModuleTool::Errors::InvalidPathInPackageError,
-                     "Attempt to install file into \"#{File.expand_path('/the/thedir')}\" under \"#{destdir}\"")
+                     "Attempt to install file with an invalid path into \"#{File.expand_path('/the/thedir')}\" under \"#{destdir}\"")
   end
 
   it "packs a tar file" do

data/spec/unit/network/http/api/indirected_routes_spec.rb

@@ -16,7 +16,6 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
   before do
     Puppet::IndirectorTesting.indirection.terminus_class = :memory
     Puppet::IndirectorTesting.indirection.terminus.clear
-    handler.stubs(:check_authorization)
     handler.stubs(:warn_if_near_expiration)
   end
 
@@ -40,19 +39,19 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if there is no environment specified" do
-      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {}) }).to raise_error(ArgumentError)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {}) }).to raise_error(bad_request_error)
     end
 
     it "should fail if the environment is not alphanumeric" do
-      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {:environment => "env ness"}) }).to raise_error(ArgumentError)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {:environment => "env ness"}) }).to raise_error(bad_request_error)
     end
 
     it "should fail if the indirection does not match the prefix" do
-      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/certificate/foo", params) }).to raise_error(ArgumentError)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/certificate/foo", params) }).to raise_error(bad_request_error)
     end
 
     it "should fail if the indirection does not have the correct version" do
-      expect(lambda { handler.uri2indirection("GET", "#{Puppet::Network::HTTP::CA_URL_PREFIX}/v3/certificate/foo", params) }).to raise_error(ArgumentError)
+      expect(lambda { handler.uri2indirection("GET", "#{Puppet::Network::HTTP::CA_URL_PREFIX}/v3/certificate/foo", params) }).to raise_error(bad_request_error)
     end
 
     it "should not pass a buck_path parameter through (See Bugs #13553, #13518, #13511)" do
@@ -76,7 +75,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if the indirection name is not alphanumeric" do
-      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/foo ness/bar", params) }).to raise_error(ArgumentError)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/foo ness/bar", params) }).to raise_error(bad_request_error)
     end
 
     it "should use the remainder of the URI as the indirection key" do
@@ -88,7 +87,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if no indirection key is specified" do
-      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node", params) }).to raise_error(ArgumentError)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node", params) }).to raise_error(bad_request_error)
     end
 
     it "should choose 'find' as the indirection method if the http method is a GET and the indirection name is singular" do
@@ -124,7 +123,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if an indirection method cannot be picked" do
-      expect(lambda { handler.uri2indirection("UPDATE", "#{master_url_prefix}/node/bar", params) }).to raise_error(ArgumentError)
+      expect(lambda { handler.uri2indirection("UPDATE", "#{master_url_prefix}/node/bar", params) }).to raise_error(method_not_allowed_error)
     end
 
     it "should not URI unescape the indirection key" do
@@ -146,7 +145,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
                                                  Not(has_entry(:environment)))
       expect(lambda { handler.uri2indirection("GET",
                                               "#{master_url_prefix}/node/bar",
-                                              {:environment => 'bogus'}) }).to raise_error(ArgumentError)
+                                              {:environment => 'bogus'}) }).to raise_error(not_found_error)
     end
 
     it "should not URI unescape the indirection key as passed through to a call to check_authorization" do
@@ -219,46 +218,37 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
   end
 
   describe "when processing a request" do
-    it "should return not_authorized_code if the request is not authorized" do
-      request = a_request_that_heads(Puppet::IndirectorTesting.new("my data"))
+    it "should raise not_authorized_error when authorization fails" do
+      data = Puppet::IndirectorTesting.new("my data")
+      indirection.save(data, "my data")
+      request = a_request_that_heads(data)
 
       handler.expects(:check_authorization).raises(Puppet::Network::AuthorizationError.new("forbidden"))
 
-      handler.call(request, response)
-
-      expect(response.code).to eq(not_authorized_code)
+      expect {
+        handler.call(request, response)
+      }.to raise_error(not_authorized_error)
     end
 
-    it "should return 'not found' if the indirection does not support remote requests" do
+    it "should raise not_found_error if the indirection does not support remote requests" do
       request = a_request_that_heads(Puppet::IndirectorTesting.new("my data"))
 
       indirection.expects(:allow_remote_requests?).returns(false)
 
-      handler.call(request, response)
-
-      expect(response.code).to eq(not_found_code)
+      expect {
+        handler.call(request, response)
+      }.to raise_error(not_found_error)
     end
 
-    it "should return 'bad request' if the environment does not exist" do
+    it "should raise not_found_error if the environment does not exist" do
       Puppet.override(:environments => Puppet::Environments::Static.new()) do
         request = a_request_that_heads(Puppet::IndirectorTesting.new("my data"))
 
-        handler.call(request, response)
-
-        expect(response.code).to eq(bad_request_code)
+        expect {
+          handler.call(request, response)
+        }.to raise_error(not_found_error)
       end
     end
-
-    it "should serialize a controller exception when an exception is thrown while finding the model instance" do
-      request = a_request_that_finds(Puppet::IndirectorTesting.new("key"))
-      handler.expects(:do_find).raises(ArgumentError, "The exception")
-
-      handler.call(request, response)
-
-      expect(response.code).to eq(bad_request_code)
-      expect(response.body).to eq("The exception")
-      expect(response.type).to eq("text/plain")
-    end
   end
 
   describe "when finding a model instance" do
@@ -273,24 +263,24 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
     end
 
-    it "responds with a not_acceptable_code error when no accept header is provided" do
+    it "raises not_acceptable_error when no accept header is provided" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_finds(data, :accept_header => nil)
 
-      handler.call(request, response)
-
-      expect(response.code).to eq(not_acceptable_code)
+      expect {
+        handler.call(request, response)
+      }.to raise_error(not_acceptable_error)
     end
 
-    it "raises an error when no accepted formats are known" do
+    it "raises not_acceptable_error when no accepted formats are known" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_finds(data, :accept_header => "unknown, also/unknown")
 
-      handler.call(request, response)
-
-      expect(response.code).to eq(not_acceptable_code)
+      expect {
+        handler.call(request, response)
+      }.to raise_error(not_acceptable_error)
     end
 
     it "should pass the result through without rendering it if the result is a string" do
@@ -305,12 +295,13 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
     end
 
-    it "should return a not_found_code when no model instance can be found" do
+    it "should raise not_found_error when no model instance can be found" do
       data = Puppet::IndirectorTesting.new("my data")
       request = a_request_that_finds(data, :accept_header => "unknown, text/pson")
 
-      handler.call(request, response)
-      expect(response.code).to eq(not_found_code)
+      expect {
+        handler.call(request, response)
+      }.to raise_error(not_found_error)
     end
   end
 
@@ -335,13 +326,13 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
     end
 
-    it "should return a not_found_code when searching returns nil" do
+    it "should raise not_found_error when searching returns nil" do
       request = a_request_that_searches(Puppet::IndirectorTesting.new("nothing"), :accept_header => "unknown, text/pson")
       indirection.expects(:search).returns(nil)
 
-      handler.call(request, response)
-
-      expect(response.code).to eq(not_found_code)
+      expect {
+        handler.call(request, response)
+      }.to raise_error(not_found_error)
     end
   end
 
@@ -383,9 +374,10 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       indirection.save(data, "my data")
       request = a_request_that_destroys(data, :accept_header => "unknown, also/unknown")
 
-      handler.call(request, response)
+      expect {
+        handler.call(request, response)
+      }.to raise_error(not_acceptable_error)
 
-      expect(response.code).to eq(not_acceptable_code)
       expect(Puppet::IndirectorTesting.indirection.find("my data")).not_to be_nil
     end
   end
@@ -449,10 +441,11 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       data = Puppet::IndirectorTesting.new("my data")
       request = a_request_that_submits(data, :accept_header => "unknown, also/unknown")
 
-      handler.call(request, response)
+      expect {
+        handler.call(request, response)
+      }.to raise_error(not_acceptable_error)
 
       expect(Puppet::IndirectorTesting.indirection.find("my data")).to be_nil
-      expect(response.code).to eq(not_acceptable_code)
     end
   end
 
@@ -467,15 +460,13 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(response.code).to eq(nil)
     end
 
-    it "should return a not_found_code when the model head call returns false" do
+    it "should raise not_found_error when the model head call returns false" do
       data = Puppet::IndirectorTesting.new("my data")
       request = a_request_that_heads(data)
 
-      handler.call(request, response)
-
-      expect(response.code).to eq(not_found_code)
-      expect(response.type).to eq("text/plain")
-      expect(response.body).to eq("Not Found: Could not find indirector_testing my data")
+      expect {
+        handler.call(request, response)
+      }.to raise_error(not_found_error)
     end
   end
 end

data/spec/unit/network/http/api/master/v3_spec.rb

@@ -1,8 +1,11 @@
 require 'spec_helper'
 
 require 'puppet/network/http'
+require 'puppet_spec/network'
 
 describe Puppet::Network::HTTP::API::Master::V3 do
+  include PuppetSpec::Network
+
   let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
   let(:master_url_prefix) { "#{Puppet::Network::HTTP::MASTER_URL_PREFIX}/v3" }
   let(:master_routes) {
@@ -29,11 +32,11 @@ describe Puppet::Network::HTTP::API::Master::V3 do
     expect(response.code).to eq(200)
   end
 
-  it "responds to unknown paths with a 404" do
+  it "responds to unknown paths by raising not_found_error" do
     request = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_url_prefix}/unknown")
-    master_routes.process(request, response)
 
-    expect(response.code).to eq(404)
-    expect(response.body).to match("Not Found: Could not find indirection 'unknown'")
+    expect {
+      master_routes.process(request, response)
+    }.to raise_error(not_found_error)
   end
 end

data/spec/unit/network/rights_spec.rb

@@ -24,7 +24,7 @@ describe Puppet::Network::Rights do
       rights = Puppet::Network::Rights.new
       why_forbidden = rights.is_request_forbidden_and_why?(:head, "/indirection_name/key", {})
       expect(why_forbidden).to be_instance_of(Puppet::Network::AuthorizationError)
-      expect(why_forbidden.to_s).to eq("Forbidden request:  access to /indirection_name/key [find]")
+      expect(why_forbidden.to_s).to eq("Forbidden request: /indirection_name/key [find]")
     end
   end
 

data/spec/unit/parameter_spec.rb

@@ -190,4 +190,15 @@ describe Puppet::Parameter do
       )).to eq("{'1' => 'foo', 'bar' => ['2', '3', '4'], 'baz' => {'quux' => 'two', 'qux' => '1'}}")
     end
   end
+
+  describe 'formatting messages' do
+    it "formats messages as-is when the parameter is not sensitive" do
+      expect(@parameter.format("hello %s", "world")).to eq("hello world")
+    end
+
+    it "formats messages with redacted values when the parameter is not sensitive" do
+      @parameter.sensitive = true
+      expect(@parameter.format("hello %s", "world")).to eq("hello [redacted]")
+    end
+  end
 end