puppet 4.0.0 → 4.9.1

data/spec/unit/indirector/rest_spec.rb

@@ -1,5 +1,6 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'json'
 require 'puppet/indirector'
 require 'puppet/indirector/errors'
 require 'puppet/indirector/rest'
@@ -12,15 +13,34 @@ shared_examples_for "a REST terminus method" do |terminus_method|
 
   HTTP_ERROR_CODES.each do |code|
     describe "when the response code is #{code}" do
-      let(:response) { mock_response(code, 'error messaged!!!') }
+      let(:message) { 'error messaged!!!' }
+      let(:body) do
+        JSON.generate({
+          :issue_kind => 'server-error',
+          :message    => message,
+          :stacktrace => ['worst/stack/trace/ever.rb:4']
+        })
+      end
+      let(:response) { mock_response(code, body, 'application/json') }
+
+      describe "when the response is plain text" do
+        let(:response) { mock_response(code, message) }
 
-      it "raises an http error with the body of the response" do
+        it "raises an http error with the body of the response when plain text" do
+
+          expect {
+            terminus.send(terminus_method, request)
+          }.to raise_error(Net::HTTPError, "Error #{code} on SERVER: #{message}")
+        end
+      end
+
+      it "raises an http error with the body's message field when json" do
         expect {
           terminus.send(terminus_method, request)
-        }.to raise_error(Net::HTTPError, "Error #{code} on SERVER: #{response.body}")
+        }.to raise_error(Net::HTTPError, "Error #{code} on SERVER: #{message}")
       end
 
-      it "does not attempt to deserialize the response" do
+      it "does not attempt to deserialize the response into a model" do
         model.expects(:convert_from).never
 
         expect {
@@ -40,15 +60,14 @@ shared_examples_for "a REST terminus method" do |terminus_method|
 
       describe "and the body is compressed" do
         it "raises an http error with the decompressed body of the response" do
-          uncompressed_body = "why"
-          compressed_body = Zlib::Deflate.deflate(uncompressed_body)
+          compressed_body = Zlib::Deflate.deflate(body)
 
-          response = mock_response(code, compressed_body, 'text/plain', 'deflate')
-          connection.expects(http_method).returns(response)
+          compressed_response = mock_response(code, compressed_body, 'application/json', 'deflate')
+          connection.expects(http_method).returns(compressed_response)
 
           expect {
             terminus.send(terminus_method, request)
-          }.to raise_error(Net::HTTPError, "Error #{code} on SERVER: #{uncompressed_body}")
+          }.to raise_error(Net::HTTPError, "Error #{code} on SERVER: #{message}")
         end
       end
     end
@@ -186,10 +205,89 @@ describe Puppet::Indirector::REST do
     expect(terminus_class.port).to eq(543)
   end
 
+  it "should use a failover-selected server if set" do
+    terminus_class.expects(:server_setting).returns nil
+    Puppet.override(:server => "myserver") do
+      expect(terminus_class.server).to eq("myserver")
+    end
+  end
+
+  it "should use a failover-selected port if set" do
+    terminus_class.expects(:port_setting).returns nil
+    Puppet.override(:serverport => 321) do
+      expect(terminus_class.port).to eq(321)
+    end
+  end
+
+  it "should use server_list for server when available" do
+    terminus_class.expects(:server_setting).returns nil
+    Puppet[:server_list] = [["foo", "123"]]
+    expect(terminus_class.server).to eq("foo")
+  end
+
+  it "should prefer failover-selected server from server list" do
+    terminus_class.expects(:server_setting).returns nil
+    Puppet[:server_list] = [["foo", "123"],["bar", "321"]]
+    Puppet.override(:server => "bar") do
+      expect(terminus_class.server).to eq("bar")
+    end
+  end
+
+  it "should use server_list for port when available" do
+    terminus_class.expects(:port_setting).returns nil
+    Puppet[:server_list] = [["foo", "123"]]
+    expect(terminus_class.port).to eq(123)
+  end
+
+  it "should prefer failover-selected port from server list" do
+    terminus_class.expects(:port_setting).returns nil
+    Puppet[:server_list] = [["foo", "123"],["bar", "321"]]
+    Puppet.override(:serverport => "321") do
+      expect(terminus_class.port).to eq(321)
+    end
+  end
+
+  it "should use an explicitly specified more-speciic server when failover is active" do
+    terminus_class.expects(:server_setting).returns :ca_server
+    Puppet[:ca_server] = "myserver"
+    Puppet.override(:server => "anotherserver") do
+      expect(terminus_class.server).to eq("myserver")
+    end
+  end
+
+  it "should use an explicitly specified more-specific port when failover is active" do
+    terminus_class.expects(:port_setting).returns :ca_port
+    Puppet[:ca_port] = 321
+    Puppet.override(:serverport => 543) do
+      expect(terminus_class.port).to eq(321)
+    end
+  end
+
+  it "should use a default port when a more-specific server is set" do
+    terminus_class.expects(:server_setting).returns :ca_server
+    terminus_class.expects(:port_setting).returns :ca_port
+    Puppet[:ca_server] = "myserver"
+    Puppet.override(:server => "anotherserver", :port => 666) do
+      expect(terminus_class.port).to eq(8140)
+    end
+  end
+
   it 'should default to :puppet for the srv_service' do
     expect(Puppet::Indirector::REST.srv_service).to eq(:puppet)
   end
 
+  it 'excludes yaml from the Accept header' do
+    model.expects(:supported_formats).returns([:pson, :yaml, :binary])
+
+    expect(terminus.headers['Accept']).to eq('pson, binary')
+  end
+
+  it 'excludes b64_zlib_yaml from the Accept header' do
+    model.expects(:supported_formats).returns([:pson, :b64_zlib_yaml])
+
+    expect(terminus.headers['Accept']).to eq('pson')
+  end
+
   describe "when creating an HTTP client" do
     it "should use the class's server and port if the indirection request provides neither" do
       @request = stub 'request', :key => "foo", :server => nil, :port => nil

data/spec/unit/indirector/ssl_file_spec.rb

@@ -108,7 +108,7 @@ describe Puppet::Indirector::SslFile do
        "//?/c:/foo",
       ].each do |input|
         it "should resist directory traversal attacks (#{input.inspect})" do
-          expect { @searcher.path(input) }.to raise_error
+          expect { @searcher.path(input) }.to raise_error(ArgumentError, /invalid key/)
         end
       end
 

data/spec/unit/indirector/yaml_spec.rb

@@ -82,7 +82,7 @@ describe Puppet::Indirector::Yaml do
      "//?/c:/foo",
     ].each do |input|
       it "should resist directory traversal attacks (#{input.inspect})" do
-        expect { @store.path(input) }.to raise_error
+        expect { @store.path(input) }.to raise_error(ArgumentError)
       end
     end
   end

data/spec/unit/info_service_spec.rb

@@ -0,0 +1,298 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+
+require 'puppet/pops'
+require 'puppet/info_service'
+require 'puppet/pops/evaluator/literal_evaluator'
+
+describe "Puppet::InfoService" do
+  context 'classes_per_environment service' do
+    include PuppetSpec::Files
+
+    let(:code_dir) do
+      dir_containing('manifests', {
+        'foo.pp' => <<-CODE,
+           class foo($foo_a, Integer $foo_b, String $foo_c = 'c default value') { }
+           class foo2($foo2_a, Integer $foo2_b, String $foo2_c = 'c default value') { }
+        CODE
+        'bar.pp' => <<-CODE,
+           class bar($bar_a, Integer $bar_b, String $bar_c = 'c default value') { }
+           class bar2($bar2_a, Integer $bar2_b, String $bar2_c = 'c default value') { }
+        CODE
+        'intp.pp' => <<-CODE,
+           class intp(String $intp_a = "default with interpolated $::os_family") { }
+        CODE
+        'fee.pp' => <<-CODE,
+           class fee(Integer $fee_a = 1+1) { }
+        CODE
+        'fum.pp' => <<-CODE,
+           class fum($fum_a) { }
+        CODE
+        'nothing.pp' => <<-CODE,
+           # not much to see here, move along
+        CODE
+        'borked.pp' => <<-CODE,
+           class Borked($Herp+$Derp) {}
+        CODE
+        'json_unsafe.pp' => <<-CODE,
+             class json_unsafe($arg1 = /.*/, $arg2 = default, $arg3 = {1 => 1}) {}
+          CODE
+       })
+    end
+
+    it "errors if not given a hash" do
+      expect{ Puppet::InfoService.classes_per_environment("you wassup?")}.to raise_error(ArgumentError, 'Given argument must be a Hash')
+    end
+
+    it "returns empty hash if given nothing" do
+      expect(Puppet::InfoService.classes_per_environment({})).to eq({})
+    end
+
+    it "produces classes and parameters from a given file" do
+      files = ['foo.pp'].map {|f| File.join(code_dir, f) }
+      result = Puppet::InfoService.classes_per_environment({'production' => files })
+      expect(result).to eq({
+        "production"=>{
+           "#{code_dir}/foo.pp"=> {:classes => [
+             {:name=>"foo",
+               :params=>[
+                 {:name=>"foo_a"},
+                 {:name=>"foo_b", :type=>"Integer"},
+                 {:name=>"foo_c", :type=>"String", :default_literal=>"c default value",
+                   :default_source=>"'c default value'"}
+               ]},
+             {:name=>"foo2",
+               :params=>[
+                 {:name=>"foo2_a"},
+                 {:name=>"foo2_b", :type=>"Integer"},
+                 {:name=>"foo2_c", :type=>"String", :default_literal=>"c default value",
+                   :default_source=>"'c default value'"}
+               ]
+             }
+           ]}} # end production env
+        })
+    end
+
+    it "produces classes and parameters from multiple files in same environment" do
+      files = ['foo.pp', 'bar.pp'].map {|f| File.join(code_dir, f) }
+      result = Puppet::InfoService.classes_per_environment({'production' => files })
+      expect(result).to eq({
+        "production"=>{
+           "#{code_dir}/foo.pp"=>{:classes => [
+             {:name=>"foo",
+               :params=>[
+                 {:name=>"foo_a"},
+                 {:name=>"foo_b", :type=>"Integer"},
+                 {:name=>"foo_c", :type=>"String", :default_literal=>"c default value",
+                   :default_source=>"'c default value'"}
+               ]},
+             {:name=>"foo2",
+               :params=>[
+                 {:name=>"foo2_a"},
+                 {:name=>"foo2_b", :type=>"Integer"},
+                 {:name=>"foo2_c", :type=>"String", :default_literal=>"c default value",
+                   :default_source=>"'c default value'"}
+               ]
+             }
+           ]},
+          "#{code_dir}/bar.pp"=> {:classes =>[
+            {:name=>"bar",
+              :params=>[
+                {:name=>"bar_a"},
+                {:name=>"bar_b", :type=>"Integer"},
+                {:name=>"bar_c", :type=>"String", :default_literal=>"c default value",
+                  :default_source=>"'c default value'"}
+              ]},
+            {:name=>"bar2",
+              :params=>[
+                {:name=>"bar2_a"},
+                {:name=>"bar2_b", :type=>"Integer"},
+                {:name=>"bar2_c", :type=>"String", :default_literal=>"c default value",
+                :default_source=>"'c default value'"}
+              ]
+            }
+          ]},
+
+          } # end production env
+        }
+      )
+    end
+
+    it "produces classes and parameters from multiple files in multiple environments" do
+      files_production = ['foo.pp', 'bar.pp'].map {|f| File.join(code_dir, f) }
+      files_test = ['fee.pp', 'fum.pp'].map {|f| File.join(code_dir, f) }
+      result = Puppet::InfoService.classes_per_environment({
+        'production' => files_production,
+        'test'       => files_test
+      })
+
+      expect(result).to eq({
+        "production"=>{
+           "#{code_dir}/foo.pp"=>{:classes => [
+             {:name=>"foo",
+               :params=>[
+                 {:name=>"foo_a"},
+                 {:name=>"foo_b", :type=>"Integer"},
+                 {:name=>"foo_c", :type=>"String", :default_literal=>"c default value",
+                   :default_source=>"'c default value'"}
+               ]},
+             {:name=>"foo2",
+               :params=>[
+                 {:name=>"foo2_a"},
+                 {:name=>"foo2_b", :type=>"Integer"},
+                 {:name=>"foo2_c", :type=>"String", :default_literal=>"c default value",
+                   :default_source=>"'c default value'"}
+               ]
+             }
+           ]},
+          "#{code_dir}/bar.pp"=>{:classes => [
+            {:name=>"bar",
+              :params=>[
+                {:name=>"bar_a"},
+                {:name=>"bar_b", :type=>"Integer"},
+                {:name=>"bar_c", :type=>"String", :default_literal=>"c default value",
+                  :default_source=>"'c default value'"}
+              ]},
+            {:name=>"bar2",
+              :params=>[
+                {:name=>"bar2_a"},
+                {:name=>"bar2_b", :type=>"Integer"},
+                {:name=>"bar2_c", :type=>"String", :default_literal=>"c default value",
+                  :default_source=>"'c default value'"}
+                ]
+              }
+          ]},
+          }, # end production env
+        "test"=>{
+           "#{code_dir}/fee.pp"=>{:classes => [
+             {:name=>"fee",
+               :params=>[
+                 {:name=>"fee_a", :type=>"Integer", :default_source=>"1+1"}
+               ]},
+           ]},
+          "#{code_dir}/fum.pp"=>{:classes => [
+            {:name=>"fum",
+              :params=>[
+                {:name=>"fum_a"}
+              ]},
+          ]},
+         } # end test env
+        }
+      )
+    end
+
+    it "avoids parsing file more than once when environments have same feature flag set" do
+      # in this version of puppet, all environments are equal in this respect
+      result = Puppet::Pops::Parser::EvaluatingParser.new.parse_file("#{code_dir}/fum.pp")
+      Puppet::Pops::Parser::EvaluatingParser.any_instance.expects(:parse_file).with("#{code_dir}/fum.pp").returns(result).once
+      files_production = ['fum.pp'].map {|f| File.join(code_dir, f) }
+      files_test       = files_production
+
+      result = Puppet::InfoService.classes_per_environment({
+        'production' => files_production,
+        'test'       => files_test
+        })
+       expect(result).to eq({
+         "production"=>{ "#{code_dir}/fum.pp"=>{:classes => [ {:name=>"fum", :params=>[ {:name=>"fum_a"}]}]}},
+         "test"      =>{ "#{code_dir}/fum.pp"=>{:classes => [ {:name=>"fum", :params=>[ {:name=>"fum_a"}]}]}}
+       }
+      )
+    end
+
+    it "produces expression string if a default value is not literal" do
+      files = ['fee.pp'].map {|f| File.join(code_dir, f) }
+      result = Puppet::InfoService.classes_per_environment({'production' => files })
+      expect(result).to eq({
+        "production"=>{
+           "#{code_dir}/fee.pp"=>{:classes => [
+             {:name=>"fee",
+               :params=>[
+                 {:name=>"fee_a", :type=>"Integer", :default_source=>"1+1"}
+               ]},
+           ]}} # end production env
+        })
+     end
+
+     it "produces source string for literals that are not pure json" do
+       files = ['json_unsafe.pp'].map {|f| File.join(code_dir, f) }
+       result = Puppet::InfoService.classes_per_environment({'production' => files })
+       expect(result).to eq({
+         "production"=>{
+            "#{code_dir}/json_unsafe.pp" => {:classes => [
+              {:name=>"json_unsafe",
+                :params => [
+                  {:name => "arg1",
+                    :default_source => "/.*/" },
+                  {:name => "arg2",
+                    :default_source => "default" },
+                  {:name => "arg3",
+                    :default_source => "{1 => 1}" }
+                ]}
+            ]}} # end production env
+         })
+     end
+
+    it "produces no type entry if type is not given" do
+      files = ['fum.pp'].map {|f| File.join(code_dir, f) }
+      result = Puppet::InfoService.classes_per_environment({'production' => files })
+      expect(result).to eq({
+        "production"=>{
+           "#{code_dir}/fum.pp"=>{:classes => [
+             {:name=>"fum",
+               :params=>[
+                 {:name=>"fum_a" }
+               ]},
+           ]}} # end production env
+        })
+    end
+
+    it 'does not evaluate default expressions' do
+      files = ['intp.pp'].map {|f| File.join(code_dir, f) }
+      result = Puppet::InfoService.classes_per_environment({'production' => files })
+      expect(result).to eq({
+        'production' =>{
+          "#{code_dir}/intp.pp"=>{:classes => [
+            {:name=> 'intp',
+              :params=>[
+                {:name=> 'intp_a',
+                  :type=> 'String',
+                  :default_source=>'"default with interpolated $::os_family"'}
+              ]},
+          ]}} # end production env
+      })
+    end
+
+    it "produces error entry if file is broken" do
+      files = ['borked.pp'].map {|f| File.join(code_dir, f) }
+       result = Puppet::InfoService.classes_per_environment({'production' => files })
+       expect(result).to eq({
+         "production"=>{
+            "#{code_dir}/borked.pp"=>
+              {:error=>"Syntax error at '+' at #{code_dir}/borked.pp:1:30",
+              },
+            } # end production env
+         })
+    end
+
+    it "produces empty {} if parsed result has no classes" do
+      files = ['nothing.pp'].map {|f| File.join(code_dir, f) }
+       result = Puppet::InfoService.classes_per_environment({'production' => files })
+       expect(result).to eq({
+         "production"=>{
+           "#{code_dir}/nothing.pp"=> {:classes => [] }
+           },
+         })
+    end
+
+    it "produces error when given a file that does not exist" do
+      files = ['the_tooth_fairy_does_not_exist.pp'].map {|f| File.join(code_dir, f) }
+      result = Puppet::InfoService.classes_per_environment({'production' => files })
+      expect(result).to eq({
+        "production"=>{
+          "#{code_dir}/the_tooth_fairy_does_not_exist.pp" => {:error  => "The file #{code_dir}/the_tooth_fairy_does_not_exist.pp does not exist"}
+             },
+        })
+    end
+
+  end
+end

data/spec/unit/interface_spec.rb

@@ -132,6 +132,33 @@ describe Puppet::Interface do
     end
   end
 
+  context "when deprecating a face" do
+    let(:face) { subject.new(:foo, '0.0.1') }
+    describe "#deprecate" do
+      it "should respond to #deprecate" do
+        expect(subject.new(:foo, '0.0.1')).to respond_to(:deprecate)
+      end
+
+      it "should set the deprecated value to true" do
+        expect(face.deprecated?).to be_falsey
+        face.deprecate
+        expect(face.deprecated?).to be_truthy
+      end
+    end
+
+    describe "#deprecated?" do
+      it "should return a nil (falsey) value by default" do
+        expect(face.deprecated?).to be_falsey
+      end
+
+      it "should return true if the face has been deprecated" do
+        expect(face.deprecated?).to be_falsey
+        face.deprecate
+        expect(face.deprecated?).to be_truthy
+      end
+    end
+  end
+
   describe "with face-level display_global_options" do
     it "should not return any action level display_global_options" do
       face = subject.new(:with_display_global_options, '0.0.1') do

data/spec/unit/man_spec.rb

@@ -23,7 +23,7 @@ describe Puppet::Face[:man, :current] do
       app = klass.new(Puppet::Util::CommandLine.new('puppet', ['man', name]))
 
       expect do
-        IO.stubs(:popen).with(pager, anything).yields($stdout)
+        IO.stubs(:popen).with(pager, 'w:UTF-8').yields($stdout)
 
         expect { app.run }.to exit_with(0)
       end.to_not have_printed(/undefined method `gsub'/)