puppet 4.4.0 → 4.5.0

data/spec/unit/network/auth_config_parser_spec.rb

@@ -4,6 +4,7 @@ require 'puppet/network/auth_config_parser'
 require 'puppet/network/authconfig'
 
 describe Puppet::Network::AuthConfigParser do
+  include PuppetSpec::Files
 
   let(:fake_authconfig) do
     "path ~ ^/catalog/([^/])\nmethod find\nallow *\n"
@@ -98,4 +99,19 @@ describe Puppet::Network::AuthConfigParser do
       described_class.new("path /certificates\nauthenticated yes").parse_rights
     end
   end
+
+  describe "when parsing rights from files" do
+    it "can read UTF-8" do
+      rune_path = "/\u16A0\u16C7\u16BB" # ᚠᛇᚻ
+      config = tmpfile('config')
+
+      File.open(config, 'w', :encoding => 'utf-8') do |file|
+        file.puts <<-EOF
+path #{rune_path}
+      EOF
+    end
+
+      expect(described_class.new_from_file(config).parse_rights[rune_path]).to be
+    end
+  end
 end

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

@@ -127,22 +127,17 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(lambda { handler.uri2indirection("UPDATE", "#{master_url_prefix}/node/bar", params) }).to raise_error(ArgumentError)
     end
 
-    it "should URI unescape the indirection key" do
+    it "should not URI unescape the indirection key" do
       escaped = URI.escape("foo bar")
-      indirection, method, key, final_params = handler.uri2indirection("GET", "#{master_url_prefix}/node/#{escaped}", params)
-      expect(key).to eq("foo bar")
+      indirection, _, key, _ = handler.uri2indirection("GET", "#{master_url_prefix}/node/#{escaped}", params)
+      expect(key).to eq(escaped)
     end
 
-    it "should pass through a proper environment param in a call to check_authorization" do
-      handler.expects(:check_authorization).with(anything,
-                                                 anything,
-                                                 all_of(
-                                                   has_entry(:environment,
-                                                             is_a(Puppet::Node::Environment)),
-                                                   has_entry(:environment,
-                                                             responds_with(:name,
-                                                                           :env))))
-      handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", params)
+    it "should not unescape the URI passed through in a call to check_authorization" do
+      key_escaped = URI.escape("foo bar")
+      uri_escaped = "#{master_url_prefix}/node/#{key_escaped}"
+      handler.expects(:check_authorization).with(anything, uri_escaped, anything)
+      indirection, _, _, _ = handler.uri2indirection("GET", uri_escaped, params)
     end
 
     it "should not pass through an environment to check_authorization and fail if the environment is unknown" do
@@ -153,6 +148,19 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
                                               "#{master_url_prefix}/node/bar",
                                               {:environment => 'bogus'}) }).to raise_error(ArgumentError)
     end
+
+    it "should not URI unescape the indirection key as passed through to a call to check_authorization" do
+      handler.expects(:check_authorization).with(anything,
+                                                 anything,
+                                                 all_of(
+                                                     has_entry(:environment,
+                                                               is_a(Puppet::Node::Environment)),
+                                                     has_entry(:environment,
+                                                               responds_with(:name,
+                                                                             :env))))
+      handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", params)
+    end
+
   end
 
   describe "when converting a request into a URI" do

data/spec/unit/network/http/api/master/v3/environment_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+require 'puppet/network/http'
+
+describe Puppet::Network::HTTP::API::Master::V3::Environment do
+  let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
+
+  around :each do |example|
+    environment = Puppet::Node::Environment.create(:production, [], '/manifests')
+    loader = Puppet::Environments::Static.new(environment)
+    Puppet.override(:environments => loader) do
+      example.run
+    end
+  end
+
+  it "returns the environment catalog" do
+    request = Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }, :routing_path => "environment/production")
+
+    subject.call(request, response)
+
+    expect(response.code).to eq(200)
+
+    catalog = JSON.parse(response.body)
+    expect(catalog['environment']).to eq('production')
+    expect(catalog['applications']).to eq({})
+  end
+
+  it "returns 404 if the environment doesn't exist" do
+    request = Puppet::Network::HTTP::Request.from_hash(:routing_path => "environment/development")
+
+    expect { subject.call(request, response) }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotFoundError, /development is not a known environment/)
+  end
+
+  it "omits code_id if unspecified" do
+    request = Puppet::Network::HTTP::Request.from_hash(:routing_path => "environment/production")
+
+    subject.call(request, response)
+
+    expect(JSON.parse(response.body)['code_id']).to be_nil
+  end
+
+  it "includes code_id if specified" do
+    request = Puppet::Network::HTTP::Request.from_hash(:params => {:code_id => '12345'}, :routing_path => "environment/production")
+
+    subject.call(request, response)
+
+    expect(JSON.parse(response.body)['code_id']).to eq('12345')
+  end
+
+  it "uses code_id from the catalog if it differs from the request" do
+    request = Puppet::Network::HTTP::Request.from_hash(:params => {:code_id => '12345'}, :routing_path => "environment/production")
+
+    Puppet::Resource::Catalog.any_instance.stubs(:code_id).returns('67890')
+
+    subject.call(request, response)
+
+    expect(JSON.parse(response.body)['code_id']).to eq('67890')
+  end
+end
+

data/spec/unit/network/http/rack/rest_spec.rb

@@ -65,6 +65,13 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
         expect(@handler.path(req)).to eq("/foo/bar")
       end
 
+      it "should return the unescaped path for an escaped request path" do
+        unescaped_path = '/foo/bar baz'
+        escaped_path = URI.escape(unescaped_path)
+        req = mk_req(escaped_path)
+        expect(@handler.path(req)).to eq(unescaped_path)
+      end
+
       it "should return the request body as the body" do
         req = mk_req('/foo/bar', :input => 'mybody')
         expect(@handler.body(req)).to eq("mybody")

data/spec/unit/node/environment_spec.rb

@@ -428,6 +428,16 @@ describe Puppet::Node::Environment do
     end
 
     describe "when performing initial import" do
+      let(:loaders) { Puppet::Pops::Loaders.new(env) }
+
+      around :each do |example|
+        Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+        Puppet.override(:loaders => loaders, :current_environment => env) do
+          example.run
+          Puppet::Pops::Loaders.clear
+        end
+      end
+
       it "loads from Puppet[:code]" do
         Puppet[:code] = "define foo {}"
         krt = env.known_resource_types

data/spec/unit/parser/compiler_spec.rb

@@ -258,7 +258,7 @@ describe Puppet::Parser::Compiler do
       expect(@compiler.topscope['c']).to eq("d")
     end
 
-    it "should set node parameters thar are of Symbol type as String variables in the top scope" do
+    it "should set node parameters that are of Symbol type as String variables in the top scope" do
       params = {"a" => :b}
       @node.stubs(:parameters).returns(params)
       compile_stub(:set_node_parameters)
@@ -838,6 +838,24 @@ describe Puppet::Parser::Compiler do
     end
   end
 
+  describe 'when using meta parameters to form relationships' do
+    include PuppetSpec::Compiler
+    [:before, :subscribe, :notify, :require].each do | meta_p |
+      it "an entry consisting of nested empty arrays is flattened for parameter #{meta_p}" do
+          expect {
+          node = Puppet::Node.new('someone')
+          manifest = <<-"MANIFEST"
+            notify{hello_kitty: message => meow, #{meta_p} => [[],[]]}
+            notify{hello_kitty2: message => meow, #{meta_p} => [[],[[]],[]]}
+          MANIFEST
+
+          catalog = compile_to_catalog(manifest, node)
+          catalog.to_ral
+        }.not_to raise_error
+      end
+    end
+  end
+
   describe "when evaluating node classes" do
     include PuppetSpec::Compiler
 
@@ -951,6 +969,7 @@ describe Puppet::Parser::Compiler do
     end
   end
 
+
   describe "when managing resource overrides" do
 
     before do

data/spec/unit/parser/functions/create_resources_spec.rb

@@ -103,7 +103,7 @@ describe 'function for dynamically creating resources' do
 
           create_resources('foocreateresource', {'blah'=>{}})
         MANIFEST
-      }.to raise_error(Puppet::Error, /Foocreateresource\[blah\]: expects a value for parameter 'one' on node foonode/)
+      }.to raise_error(Puppet::Error, /Foocreateresource\[blah\]: expects a value for parameter 'one' on node test/)
     end
 
     it 'should be able to add multiple defines' do
@@ -169,7 +169,7 @@ describe 'function for dynamically creating resources' do
         compile_to_catalog(<<-MANIFEST)
           create_resources('class', {'blah'=>{'one'=>'two'}})
         MANIFEST
-      end.to raise_error(/Could not find declared class blah at line 1:11 on node foonode/)
+      end.to raise_error(/Could not find declared class blah at line 1:11 on node test/)
     end
 
     it 'should be able to add edges' do

data/spec/unit/parser/functions/shared.rb

@@ -24,7 +24,7 @@ shared_examples_for 'all functions transforming relative to absolute names' do |
   it 'raises and error for Resource that is not of class type' do
     expect {
       @scope.send(func_method, [Puppet::Pops::Types::TypeFactory.resource('file')])
-    }.to raise_error(ArgumentError, /Cannot use a Resource\[file\] where a Resource\['class', name\] is expected/)
+    }.to raise_error(ArgumentError, /Cannot use a Resource\[File\] where a Resource\['class', name\] is expected/)
   end
 
   it 'raises and error for Resource that is unspecific' do

data/spec/unit/parser/resource_spec.rb

@@ -193,6 +193,13 @@ describe Puppet::Parser::Resource do
       expect(@compiler.catalog).to be_edge(foo_stage, resource)
     end
 
+    it 'should allow a resource reference to be undef' do
+      Puppet[:code] = "notify { 'hello': message=>'yo', notify => undef }"
+      catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new 'anyone')
+      edges = catalog.edges.map {|e| [e.source.ref, e.target.ref]}
+      expect(edges).to include(['Class[main]', 'Notify[hello]'])
+    end
+
     it "should allow edges to propagate multiple levels down the scope hierarchy" do
       Puppet[:code] = <<-MANIFEST
         stage { before: before => Stage[main] }
@@ -556,7 +563,7 @@ describe Puppet::Parser::Resource do
 
   # part of #629 -- the undef keyword.  Make sure 'undef' params get skipped.
   it "should not include 'undef' parameters when converting itself to a hash" do
-    resource = Puppet::Parser::Resource.new "file", "/tmp/testing", :source => mock("source"), :scope => mock("scope")
+    resource = Puppet::Parser::Resource.new "file", "/tmp/testing", :source => mock("source"), :scope => @scope
     resource[:owner] = :undef
     resource[:mode] = "755"
     expect(resource.to_hash[:owner]).to be_nil

data/spec/unit/parser/scope_spec.rb

@@ -324,6 +324,51 @@ describe Puppet::Parser::Scope do
         expect { @scope['module_name'] }.to_not raise_error
       end
     end
+
+    context "and strict_variables is false and --strict=off" do
+      before(:each) do
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :off
+      end
+
+      it "should not error when unknown variable is looked up and produce nil" do
+        expect(@scope['john_doe']).to be_nil
+      end
+
+      it "should not error when unknown qualified variable is looked up and produce nil" do
+        expect(@scope['nowhere::john_doe']).to be_nil
+      end
+    end
+
+    context "and strict_variables is false and --strict=warning" do
+      before(:each) do
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :warning
+      end
+
+      it "should not error when unknown variable is looked up" do
+        expect(@scope['john_doe']).to be_nil
+      end
+
+      it "should not error when unknown qualified variable is looked up" do
+        expect(@scope['nowhere::john_doe']).to be_nil
+      end
+    end
+
+    context "and strict_variables is false and --strict=error" do
+      before(:each) do
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :error
+      end
+
+      it "should raise error when unknown variable is looked up" do
+        expect { @scope['john_doe'] }.to raise_error(/Undefined variable/)
+      end
+
+      it "should not throw a symbol when unknown qualified variable is looked up" do
+        expect { @scope['nowhere::john_doe'] }.to raise_error(/Undefined variable/)
+      end
+    end
   end
 
   describe "when variables are set with append=true" do

data/spec/unit/pops/evaluator/access_ops_spec.rb

@@ -166,6 +166,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
 
     # Hash Type
     #
+    it 'produces a Hash[0, 0] from the expression Hash[0, 0]' do
+      expr = fqr('Hash')[0, 0]
+      expect(evaluate(expr)).to be_the_type(types.hash_of(types.default, types.default, types.range(0, 0)))
+    end
+
     it 'produces a Hash[Scalar,String] from the expression Hash[Scalar, String]' do
       expr = fqr('Hash')[fqr('Scalar'), fqr('String')]
       expect(evaluate(expr)).to be_the_type(types.hash_of(types.string, types.scalar))
@@ -192,6 +197,15 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
 
     # Array Type
     #
+    it 'produces an Array[0, 0] from the expression Array[0, 0]' do
+      expr = fqr('Array')[0, 0]
+      expect(evaluate(expr)).to be_the_type(types.array_of(types.default, types.range(0, 0)))
+
+      # arguments are flattened
+      expr = fqr('Array')[[fqr('String')]]
+      expect(evaluate(expr)).to be_the_type(types.array_of(types.string))
+    end
+
     it 'produces an Array[String] from the expression Array[String]' do
       expr = fqr('Array')[fqr('String')]
       expect(evaluate(expr)).to be_the_type(types.array_of(types.string))

data/spec/unit/pops/evaluator/evaluating_parser_spec.rb

@@ -57,7 +57,15 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
-      end
+    end
+
+    it 'should error when it encounters an unknown resource' do
+      expect {parser.evaluate_string(scope, '$a = SantaClause', __FILE__)}.to raise_error(/Resource type not found: SantaClause/)
+    end
+
+    it 'should error when it encounters an unknown resource with a parameter' do
+      expect {parser.evaluate_string(scope, '$b = ToothFairy[emea]', __FILE__)}.to raise_error(/Resource type not found: ToothFairy/)
+    end
   end
 
   context "When the evaluator evaluates Lists and Hashes" do
@@ -253,9 +261,9 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "xxx in bananas"                => false,
       "/ana/ in bananas"              => true,
       "/xxx/ in bananas"              => false,
-      "ANA in bananas"                => false, # ANA is a type, not a String
+      "FILE in profiler"              => false, # FILE is a type, not a String
+      "'FILE' in profiler"            => true,
       "String[1] in bananas"          => false, # Philosophically true though :-)
-      "'ANA' in bananas"              => true,
       "ana in 'BANANAS'"              => true,
       "/ana/ in 'BANANAS'"            => false,
       "/ANA/ in 'BANANAS'"            => true,
@@ -307,13 +315,13 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
 
     {
       'Any'  => ['NotUndef', 'Data', 'Scalar', 'Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern', 'Collection',
-                    'Array', 'Hash', 'CatalogEntry', 'Resource', 'Class', 'Undef', 'File', 'NotYetKnownResourceType'],
+                    'Array', 'Hash', 'CatalogEntry', 'Resource', 'Class', 'Undef', 'File' ],
 
       # Note, Data > Collection is false (so not included)
       'Data'    => ['Scalar', 'Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern', 'Array', 'Hash',],
       'Scalar' => ['Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern'],
       'Numeric' => ['Integer', 'Float'],
-      'CatalogEntry' => ['Class', 'Resource', 'File', 'NotYetKnownResourceType'],
+      'CatalogEntry' => ['Class', 'Resource', 'File'],
       'Integer[1,10]' => ['Integer[2,3]'],
     }.each do |general, specials|
       specials.each do |special |

data/spec/unit/pops/loaders/loaders_spec.rb

@@ -107,7 +107,7 @@ describe 'loaders' do
     end
 
     it 'loader allows loading a function more than once' do
-      File.stubs(:read).with(user_metadata_path).returns ''
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns ''
 
       env = environment_for(File.join(dependent_modules_with_metadata, 'modules'))
       loaders = Puppet::Pops::Loaders.new(env)
@@ -166,7 +166,7 @@ describe 'loaders' do
     end
 
     it 'all dependent modules are visible' do
-      File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'}, { 'name' => 'test-usee2'} ]).to_pson
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'}, { 'name' => 'test-usee2'} ]).to_pson
       loaders = Puppet::Pops::Loaders.new(env)
 
       moduleb_loader = loaders.private_loader_for_module('user')
@@ -183,7 +183,7 @@ describe 'loaders' do
         {:from => from, :called => 'a ruby function', :expects => "I'm the function usee::usee_ruby()"} ].each_with_index do |desc, called_idx|
         case_number = from_idx * 3 + called_idx + 1
         it "can call #{desc[:called]} from #{desc[:from]} when dependency is present in metadata.json" do
-          File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+          File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
           Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
           catalog = compiler.compile
           resource = catalog.resource('Notify', "case_#{case_number}")
@@ -201,7 +201,7 @@ describe 'loaders' do
         end
 
         it 'can not call ruby function in a dependent module from outside a function if dependency is missing in existing metadata.json' do
-          File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => []).to_pson
+          File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => []).to_pson
           Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
           expect { catalog = compiler.compile }.to raise_error(Puppet::Error, /Unknown function/)
         end
@@ -209,7 +209,7 @@ describe 'loaders' do
     end
 
     it "a type can reference an autoloaded type alias from another module when dependency is present in metadata.json" do
-      File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         assert_type(Usee::Zero, 0)
         notice(ok)
@@ -225,7 +225,7 @@ describe 'loaders' do
     end
 
     it "a type can reference a type alias from another module when other module has it declared in init.pp" do
-      File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         include 'usee'
         assert_type(Usee::One, 1)
@@ -234,7 +234,7 @@ describe 'loaders' do
     end
 
     it "an autoloaded type can reference an autoloaded type alias from another module when dependency is present in metadata.json" do
-      File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         assert_type(User::WithUseeZero, [0])
         notice(ok)
@@ -242,7 +242,7 @@ describe 'loaders' do
     end
 
     it "an autoloaded type can reference an autoloaded type alias from another module when other module has it declared in init.pp" do
-      File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         include 'usee'
         assert_type(User::WithUseeOne, [1])