puppet 4.10.12-universal-darwin → 5.0.0-universal-darwin

data/spec/unit/indirector/node/write_only_yaml_spec.rb

@@ -0,0 +1,12 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/node'
+require 'puppet/indirector/node/write_only_yaml'
+
+describe Puppet::Node::WriteOnlyYaml do
+  it "should be deprecated" do
+    Puppet.expects(:warn_once).with('deprecations', 'Puppet::Node::WriteOnlyYaml', 'Puppet::Node::WriteOnlyYaml is deprecated and will be removed in a future release of Puppet.')
+    described_class.new
+  end
+end

data/spec/unit/indirector/report/processor_spec.rb

@@ -30,7 +30,7 @@ describe Puppet::Transaction::Report::Processor, " when processing a report" do
     Puppet[:reports] = 'none'
 
     request = Puppet::Indirector::Request.new(:indirection_name, :head, "key", nil)
-    report = Puppet::Transaction::Report.new('apply')
+    report = Puppet::Transaction::Report.new
     request.instance = report
 
     @reporter.save(request)
@@ -66,7 +66,7 @@ describe Puppet::Transaction::Report::Processor, " when processing a report" do
     @report_type = mock 'one'
     @dup_report = mock 'dupe report'
     @dup_report.stubs(:process)
-    @report = Puppet::Transaction::Report.new('apply')
+    @report = Puppet::Transaction::Report.new
     @report.expects(:dup).returns(@dup_report)
 
     @request = stub 'request', :instance => @report

data/spec/unit/indirector/report/rest_spec.rb

@@ -45,23 +45,49 @@ describe Puppet::Transaction::Report::Rest do
   end
 
   describe "#save" do
-    let(:http_method) { :put }
     let(:response) { mock_response(200, 'body') }
     let(:connection) { stub('mock http connection', :put => response, :verify_callback= => nil) }
     let(:instance) { model.new('the thing', 'some contents') }
     let(:request) { save_request(instance.name, instance) }
+    let(:body) { ["store", "http"].to_pson }
 
     before :each do
       terminus.stubs(:network).returns(connection)
     end
 
     it "deserializes the response as an array of report processor names" do
-      processors = ["store", "http"]
-      body = processors.to_pson()
       response = mock_response('200', body, 'text/pson')
       connection.expects(:put).returns response
 
       expect(terminus.save(request)).to eq(["store", "http"])
     end
+
+    describe "when handling the response" do
+      describe "when the server major version is less than 5" do
+        it "raises if the save fails and we're not using pson" do
+          Puppet[:preferred_serialization_format] = "json"
+
+          response = mock_response('500', '{}', 'text/pson')
+          response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns("4.10.1")
+          connection.expects(:put).returns response
+
+          expect {
+            terminus.save(request)
+          }.to raise_error(Puppet::Error, /Server version 4.10.1 does not accept reports in 'json'/)
+        end
+
+        it "raises with HTTP 500 if the save fails and we're already using pson" do
+          Puppet[:preferred_serialization_format] = "pson"
+
+          response = mock_response('500', '{}', 'text/pson')
+          response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns("4.10.1")
+          connection.expects(:put).returns response
+
+          expect {
+            terminus.save(request)
+          }.to raise_error(Net::HTTPError, /Error 500 on SERVER/)
+        end
+      end
+    end
   end
 end

data/spec/unit/indirector/request_spec.rb

@@ -245,10 +245,6 @@ describe Puppet::Indirector::Request do
     expect(Puppet::Indirector::Request.new(:myind, :find, "key", nil).description).to eq("/myind/key")
   end
 
-  it "should be able to return the URI-escaped key" do
-    expect(Puppet::Indirector::Request.new(:myind, :find, "my key", nil).escaped_key).to eq(Puppet::Util.uri_encode("my key"))
-  end
-
   it "should set its environment to an environment instance when a string is specified as its environment" do
     env = Puppet::Node::Environment.create(:foo, [])
 
@@ -521,45 +517,4 @@ describe Puppet::Indirector::Request do
       expect(request(:node => 'example.com', :ip => '127.0.0.1')).to be_remote
     end
   end
-
-  describe "failover" do
-    it "should use the provided failover host and port" do
-      Puppet.override(:server => 'myhost', :serverport => 666) do
-        req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
-        req.do_request() do |request|
-          expect(request.server).to eq('myhost')
-          expect(request.port).to eq(666)
-        end
-      end
-    end
-
-    it "should not use raw settings when failover fails" do
-      Puppet.override(:server => nil, :serverport => nil) do
-        req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
-        req.do_request() do |request|
-          expect(request.server).to be_nil
-          expect(request.port).to be_nil
-          expect(Puppet.settings[:server]).not_to be_nil
-          expect(Puppet.settings[:masterport]).not_to be_nil
-        end
-      end
-    end
-
-    it "should use server_list when set and failover has not occured" do
-      Puppet.settings[:server_list] = [['myhost',666]]
-      req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
-      req.do_request() do |request|
-        expect(request.server).to eq('myhost')
-        expect(request.port).to eq(666)
-      end
-    end
-
-    it "should use server when server_list is not set" do
-      req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
-      req.do_request() do |request|
-        expect(request.server).to eq(Puppet.settings[:server])
-        expect(request.port).to eq(Puppet.settings[:masterport])
-      end
-    end
-  end
 end

data/spec/unit/indirector/rest_spec.rb

@@ -11,14 +11,50 @@ HTTP_ERROR_CODES = [300, 400, 500]
 # Just one from each category since the code makes no real distinctions
 shared_examples_for "a REST terminus method" do |terminus_method|
 
+  describe "when handling the response" do
+    let(:response) do
+      mock_response(200, 'OK')
+    end
+
+    it "falls back to pson for future requests" do
+      response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns("4.10.1")
+      terminus.send(terminus_method, request)
+
+      expect(Puppet[:preferred_serialization_format]).to eq("pson")
+    end
+
+    it "doesn't change the serialization format if the X-Puppet-Version header is missing" do
+      response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns(nil)
+
+      terminus.send(terminus_method, request)
+
+      expect(Puppet[:preferred_serialization_format]).to eq("json")
+    end
+
+    it "doesn't change the serialization format if the server major version is 5" do
+      response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns("5.0.3")
+
+      terminus.send(terminus_method, request)
+
+      expect(Puppet[:preferred_serialization_format]).to eq("json")
+    end
+
+    it "doesn't change the serialization format if the current format is already pson" do
+      response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns("4.10.1")
+      Puppet[:preferred_serialization_format] = "pson"
+      terminus.send(terminus_method, request)
+
+      expect(Puppet[:preferred_serialization_format]).to eq("pson")
+    end
+  end
+
   HTTP_ERROR_CODES.each do |code|
     describe "when the response code is #{code}" do
       let(:message) { 'error messaged!!!' }
       let(:body) do
         JSON.generate({
           :issue_kind => 'server-error',
-          :message    => message,
-          :stacktrace => ['worst/stack/trace/ever.rb:4']
+          :message    => message
         })
       end
       let(:response) { mock_response(code, body, 'application/json') }
@@ -277,15 +313,21 @@ describe Puppet::Indirector::REST do
   end
 
   it 'excludes yaml from the Accept header' do
-    model.expects(:supported_formats).returns([:pson, :yaml, :binary])
+    model.expects(:supported_formats).returns([:json, :pson, :yaml, :binary])
 
-    expect(terminus.headers['Accept']).to eq('pson, binary')
+    expect(terminus.headers['Accept']).to eq('application/json, text/pson, application/octet-stream')
   end
 
   it 'excludes b64_zlib_yaml from the Accept header' do
-    model.expects(:supported_formats).returns([:pson, :b64_zlib_yaml])
+    model.expects(:supported_formats).returns([:json, :pson, :b64_zlib_yaml])
+
+    expect(terminus.headers['Accept']).to eq('application/json, text/pson')
+  end
+
+  it 'excludes dot from the Accept header' do
+    model.expects(:supported_formats).returns([:json, :dot])
 
-    expect(terminus.headers['Accept']).to eq('pson')
+    expect(terminus.headers['Accept']).to eq('application/json')
   end
 
   describe "when creating an HTTP client" do
@@ -433,10 +475,10 @@ describe Puppet::Indirector::REST do
       expect(terminus.find(request)).to eq(model.new('name', 'decoded body'))
     end
 
-    it "provides an Accept header containing the list of supported formats joined with commas" do
-      connection.expects(:get).with(anything, has_entry("Accept" => "supported, formats")).returns(response)
+    it "provides an Accept header containing the list of supported mime types joined with commas" do
+      connection.expects(:get).with(anything, has_entry("Accept" => "application/json, text/pson")).returns(response)
 
-      terminus.model.expects(:supported_formats).returns %w{supported formats}
+      terminus.model.expects(:supported_formats).returns [:json, :pson]
       terminus.find(request)
     end
 
@@ -539,9 +581,9 @@ describe Puppet::Indirector::REST do
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
-      connection.expects(:get).with(anything, has_entry("Accept" => "supported, formats")).returns(mock_response(200, ''))
+      connection.expects(:get).with(anything, has_entry("Accept" => "application/json, text/pson")).returns(mock_response(200, ''))
 
-      terminus.model.expects(:supported_formats).returns %w{supported formats}
+      terminus.model.expects(:supported_formats).returns [:json, :pson]
       terminus.search(request)
     end
 
@@ -598,9 +640,9 @@ describe Puppet::Indirector::REST do
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
-      connection.expects(:delete).with(anything, has_entry("Accept" => "supported, formats")).returns(response)
+      connection.expects(:delete).with(anything, has_entry("Accept" => "application/json, text/pson")).returns(response)
 
-      terminus.model.expects(:supported_formats).returns %w{supported formats}
+      terminus.model.expects(:supported_formats).returns [:json, :pson]
       terminus.destroy(request)
     end
 
@@ -658,10 +700,10 @@ describe Puppet::Indirector::REST do
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
-      connection.expects(:put).with(anything, anything, has_entry("Accept" => "supported, formats")).returns(response)
+      connection.expects(:put).with(anything, anything, has_entry("Accept" => "application/json, text/pson")).returns(response)
 
       instance.expects(:render).returns('')
-      model.expects(:supported_formats).returns %w{supported formats}
+      model.expects(:supported_formats).returns [:json, :pson]
       instance.expects(:mime).returns "supported"
 
       terminus.save(request)

data/spec/unit/interface/face_collection_spec.rb

@@ -47,7 +47,7 @@ describe Puppet::Interface::FaceCollection do
 
   describe "::[]" do
     before :each do
-      subject.instance_variable_get("@faces")[:foo][SemVer.new('0.0.1')] = 10
+      subject.instance_variable_get("@faces")[:foo][SemanticPuppet::Version.parse('0.0.1')] = 10
     end
 
     it "should return the face with the given name" do
@@ -66,13 +66,13 @@ describe Puppet::Interface::FaceCollection do
     end
 
     it "should return true if the face specified is registered" do
-      subject.instance_variable_get("@faces")[:foo][SemVer.new('0.0.1')] = 10
+      subject.instance_variable_get("@faces")[:foo][SemanticPuppet::Version.parse('0.0.1')] = 10
       expect(subject["foo", '0.0.1']).to eq(10)
     end
 
     it "should attempt to require the face if it is not registered" do
       subject.expects(:require).with do |file|
-        subject.instance_variable_get("@faces")[:bar][SemVer.new('0.0.1')] = true
+        subject.instance_variable_get("@faces")[:bar][SemanticPuppet::Version.parse('0.0.1')] = true
         file == 'puppet/face/bar'
       end
       expect(subject["bar", '0.0.1']).to be_truthy
@@ -130,14 +130,14 @@ describe Puppet::Interface::FaceCollection do
         get_action_for_face(:huzzah, :obsolete, :current)
 
       expect(action).to be_an_instance_of Puppet::Interface::Action
-      expect(action.face.version).to eq(SemVer.new('1.0.0'))
+      expect(action.face.version).to eq(SemanticPuppet::Version.parse('1.0.0'))
     end
 
     it "should load the full older version of a face" do
       action = Puppet::Face::FaceCollection.
         get_action_for_face(:huzzah, :obsolete, :current)
 
-      expect(action.face.version).to eq(SemVer.new('1.0.0'))
+      expect(action.face.version).to eq(SemanticPuppet::Version.parse('1.0.0'))
       expect(action.face).to be_action :obsolete_in_core
     end
 
@@ -145,11 +145,11 @@ describe Puppet::Interface::FaceCollection do
       action = Puppet::Face::FaceCollection.
         get_action_for_face(:huzzah, :obsolete, :current)
 
-      expect(action.face.version).to eq(SemVer.new('1.0.0'))
+      expect(action.face.version).to eq(SemanticPuppet::Version.parse('1.0.0'))
       expect(action.face).to be_action :obsolete_in_core
 
       current = Puppet::Face[:huzzah, :current]
-      expect(current.version).to eq(SemVer.new('2.0.1'))
+      expect(current.version).to eq(SemanticPuppet::Version.parse('2.0.1'))
       expect(current).not_to be_action :obsolete_in_core
       expect(current).not_to be_action :obsolete
     end

data/spec/unit/interface_spec.rb

@@ -126,18 +126,6 @@ describe Puppet::Interface do
     expect { subject[:foo, '0.0.1'] }.to raise_error Puppet::Error
   end
 
-  describe 'when raising NoMethodErrors' do
-    subject { described_class.new(:foo, '1.0.0') }
-
-    it 'includes the face name in the error message' do
-      expect { subject.boombaz }.to raise_error(NoMethodError, /#{subject.name}/)
-    end
-
-    it 'includes the face version in the error message' do
-      expect { subject.boombaz }.to raise_error(NoMethodError, /#{subject.version}/)
-    end
-  end
-
   it_should_behave_like "things that declare options" do
     def add_options_to(&block)
       subject.new(:with_options, '0.0.1', &block)

data/spec/unit/module_spec.rb

@@ -440,35 +440,6 @@ describe Puppet::Module do
     end
   end
 
-
-  describe "initialize_i18n" do
-
-    let(:modpath) { tmpdir('modpath') }
-    let(:modname) { 'puppetlabs-i18n'}
-    let(:modroot) { "#{modpath}/#{modname}/" }
-    let(:config_path) { "#{modroot}/locales/config.yaml" }
-    let(:mod_obj) { PuppetSpec::Modules.create( modname, modpath, :metadata => { :dependencies => [] }, :env => env ) }
-
-    it "is expected to initialize an un-initialized module" do
-      expect(GettextSetup.translation_repositories.has_key? modname).to be false
-
-      FileUtils.mkdir_p("#{mod_obj.path}/locales")
-      config = {
-        "gettext" => {
-          "project_name" => modname
-        }
-      }
-      File.open(config_path, 'w') { |file| file.write(config.to_yaml) }
-
-      mod_obj.initialize_i18n
-
-      expect(GettextSetup.translation_repositories.has_key? modname).to be true
-    end
-    it "is expected return nil if module is intiailized" do
-      expect(mod_obj.initialize_i18n).to be nil
-    end
-  end
-
   describe "when managing supported platforms" do
     it "should support specifying a supported platform" do
       mod.supports "solaris"
@@ -694,7 +665,15 @@ describe Puppet::Module do
         Puppet[:strict] = :off
       end
 
-      it "should warn about a failure to parse" do
+      it "should not warn about a failure to parse" do
+        File.stubs(:read).with(mymod_metadata, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
+
+        expect(mymod.has_metadata?).to be_falsey
+        expect(@logs).to_not have_matching_log(/mymod has an invalid and unparsable metadata\.json file.*/)
+      end
+
+      it "should log debug output about a failure to parse when --debug is on" do
+        Puppet[:log_level] = :debug
         File.stubs(:read).with(mymod_metadata, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
 
         expect(mymod.has_metadata?).to be_falsey
@@ -717,7 +696,7 @@ describe Puppet::Module do
     end
 
   def a_module_with_metadata(data)
-    File.stubs(:read).with("/path/metadata.json", {:encoding => 'utf-8'}).returns data.to_pson
+    File.stubs(:read).with("/path/metadata.json", {:encoding => 'utf-8'}).returns data.to_json
     Puppet::Module.new("foo", "/path", mock("env"))
   end
 

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

@@ -2,7 +2,6 @@ require 'spec_helper'
 require 'puppet/module_tool/applications'
 require 'puppet_spec/module_tool/shared_functions'
 require 'puppet_spec/module_tool/stub_source'
-require 'semver'
 
 require 'tmpdir'
 

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

@@ -2,7 +2,6 @@ require 'spec_helper'
 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

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

@@ -8,17 +8,10 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
   let(:destfile)   { '/the/dest/file.tar.gz' }
   let(:minitar)    { described_class.new }
 
-  class MockFileStatEntry
-    def initialize(mode = 0100)
-      @mode = mode
-    end
-  end
-
-  it "unpacks a tar file with correct permissions" do
-    entry = unpacks_the_entry(:file_start, 'thefile')
+  it "unpacks a tar file" do
+    unpacks_the_entry(:file_start, 'thefile')
 
     minitar.unpack(sourcefile, destdir, 'uid')
-    expect(entry.instance_variable_get(:@mode)).to eq(0755)
   end
 
   it "does not allow an absolute path" do
@@ -48,42 +41,20 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
                      "Attempt to install file with an invalid path into \"#{File.expand_path('/the/thedir')}\" under \"#{destdir}\"")
   end
 
-  it "unpacks on Windows" do
-    unpacks_the_entry(:file_start, 'thefile', nil)
-
-    entry = minitar.unpack(sourcefile, destdir, 'uid')
-    # Windows does not use these permissions.
-    expect(entry.instance_variable_get(:@mode)).to eq(nil)
-  end
-
   it "packs a tar file" do
     writer = stub('GzipWriter')
 
     Zlib::GzipWriter.expects(:open).with(destfile).yields(writer)
-    stats = {:mode => 0222}
-    Archive::Tar::Minitar.expects(:pack).with(sourcedir, writer).yields(:file_start, 'abc', stats)
-
-    minitar.pack(sourcedir, destfile)
-  end
-
-  it "packs a tar file on Windows" do
-    writer = stub('GzipWriter')
-
-    Zlib::GzipWriter.expects(:open).with(destfile).yields(writer)
-    Archive::Tar::Minitar.expects(:pack).with(sourcedir, writer).
-        yields(:file_start, 'abc', {:entry => MockFileStatEntry.new(nil)})
+    Archive::Tar::Minitar.expects(:pack).with(sourcedir, writer)
 
     minitar.pack(sourcedir, destfile)
   end
 
-  def unpacks_the_entry(type, name, mode = 0100)
+  def unpacks_the_entry(type, name)
     reader = stub('GzipReader')
 
     Zlib::GzipReader.expects(:open).with(sourcefile).yields(reader)
     minitar.expects(:find_valid_files).with(reader).returns([name])
-    entry = MockFileStatEntry.new(mode)
-    Archive::Tar::Minitar.expects(:unpack).with(reader, destdir, [name]).
-        yields(type, name, {:entry => entry})
-    entry
+    Archive::Tar::Minitar.expects(:unpack).with(reader, destdir, [name]).yields(type, name, nil)
   end
 end