puppet 3.5.1-x86-mingw32 → 3.6.0.rc1-x86-mingw32

data/spec/unit/network/formats_spec.rb

@@ -50,14 +50,14 @@ describe "Puppet Network Format" do
     end
 
     it "should be able to serialize a catalog" do
-      cat = Puppet::Resource::Catalog.new('foo')
+      cat = Puppet::Resource::Catalog.new('foo', Puppet::Node::Environment.create(:testing, []))
       cat.add_resource(Puppet::Resource.new(:file, 'my_file'))
       catunpack = MessagePack.unpack(cat.to_msgpack)
       catunpack.should include(
         "tags"=>[],
         "name"=>"foo",
         "version"=>nil,
-        "environment"=>"",
+        "environment"=>"testing",
         "edges"=>[],
         "classes"=>[]
       )

data/spec/unit/network/http_pool_spec.rb

@@ -17,6 +17,27 @@ describe Puppet::Network::HttpPool do
       http.port.should    == 54321
     end
 
+    it "should support using an alternate http client implementation" do
+      begin
+        class FooClient
+          def initialize(host, port, options = {})
+            @host = host
+            @port = port
+          end
+          attr_reader :host, :port
+        end
+
+        orig_class = Puppet::Network::HttpPool.http_client_class
+        Puppet::Network::HttpPool.http_client_class = FooClient
+        http = Puppet::Network::HttpPool.http_instance("me", 54321)
+        http.should be_an_instance_of FooClient
+        http.host.should == 'me'
+        http.port.should == 54321
+      ensure
+        Puppet::Network::HttpPool.http_client_class = orig_class
+      end
+    end
+
     it "should enable ssl on the http instance by default" do
       Puppet::Network::HttpPool.http_instance("me", 54321).should be_use_ssl
     end

data/spec/unit/network/rights_spec.rb

@@ -355,11 +355,12 @@ describe Puppet::Network::Rights do
     end
 
     it "should allow setting an environment filters" do
-      Puppet::Node::Environment.stubs(:new).with(:environment).returns(:env)
+      env = Puppet::Node::Environment.create(:acltest, [])
+      Puppet.override(:environments => Puppet::Environments::Static.new(env)) do
+        @acl.restrict_environment(:acltest)
 
-      @acl.restrict_environment(:environment)
-
-      @acl.environment.should == [:env]
+        @acl.environment.should == [env]
+      end
     end
 
     ["on", "yes", "true", true].each do |auth|
@@ -392,11 +393,12 @@ describe Puppet::Network::Rights do
       end
 
       it "should return :dunno if this right is not restricted to the given environment" do
-        Puppet::Node::Environment.stubs(:new).returns(:production)
-
-        @acl.restrict_environment(:production)
+        prod = Puppet::Node::Environment.create(:prod, [])
+        Puppet.override(:environments => Puppet::Environments::Static.new(prod)) do
+          @acl.restrict_environment(:production)
 
-        @acl.allowed?("me","127.0.0.1", { :method => :save, :environment => :development }).should == :dunno
+          @acl.allowed?("me","127.0.0.1", { :method => :save, :environment => :development }).should == :dunno
+        end
       end
 
       it "should return :dunno if this right is not restricted to the given request authentication state" do

data/spec/unit/node/environment_spec.rb

@@ -46,7 +46,7 @@ describe Puppet::Node::Environment do
     describe "overriding an existing environment" do
       let(:original_path) { [tmpdir('original')] }
       let(:new_path) { [tmpdir('new')] }
-      let(:environment) { Puppet::Node::Environment.create(:overridden, original_path, 'orig.pp') }
+      let(:environment) { Puppet::Node::Environment.create(:overridden, original_path, 'orig.pp', '/config/script') }
 
       it "overrides modulepath" do
         overridden = environment.override_with(:modulepath => new_path)
@@ -54,6 +54,7 @@ describe Puppet::Node::Environment do
         expect(overridden.name).to eq(:overridden)
         expect(overridden.manifest).to eq(File.expand_path('orig.pp'))
         expect(overridden.modulepath).to eq(new_path)
+        expect(overridden.config_version).to eq('/config/script')
       end
 
       it "overrides manifest" do
@@ -62,6 +63,16 @@ describe Puppet::Node::Environment do
         expect(overridden.name).to eq(:overridden)
         expect(overridden.manifest).to eq(File.expand_path('new.pp'))
         expect(overridden.modulepath).to eq(original_path)
+        expect(overridden.config_version).to eq('/config/script')
+      end
+
+      it "overrides config_version" do
+        overridden = environment.override_with(:config_version => '/new/script')
+        expect(overridden).to_not be_equal(environment)
+        expect(overridden.name).to eq(:overridden)
+        expect(overridden.manifest).to eq(File.expand_path('orig.pp'))
+        expect(overridden.modulepath).to eq(original_path)
+        expect(overridden.config_version).to eq('/new/script')
       end
     end
 
@@ -149,6 +160,20 @@ describe Puppet::Node::Environment do
         env.should respond_to(:[])
       end
 
+      it "obtains its core values from the puppet settings instance as a legacy env" do
+        Puppet.settings.parse_config(<<-CONF)
+        [testing]
+        manifest = /some/manifest
+        modulepath = /some/modulepath
+        config_version = /some/script
+        CONF
+
+        env = Puppet::Node::Environment.new("testing")
+        expect(env.full_modulepath).to eq([File.expand_path('/some/modulepath')])
+        expect(env.manifest).to eq(File.expand_path('/some/manifest'))
+        expect(env.config_version).to eq('/some/script')
+      end
+
       it "should ask the Puppet settings instance for the setting qualified with the environment name" do
         Puppet.settings.parse_config(<<-CONF)
         [testing]
@@ -251,7 +276,7 @@ describe Puppet::Node::Environment do
               @first,
               :metadata => {
                 :author       => 'puppetlabs',
-                :dependencies => [{ 'name' => 'puppetlabs/bar', "version_requirement" => "3.0.0" }]
+                :dependencies => [{ 'name' => 'puppetlabs-bar', "version_requirement" => "3.0.0" }]
               }
             )
             PuppetSpec::Modules.create(

data/spec/unit/parser/collector_spec.rb

@@ -407,7 +407,7 @@ describe Puppet::Parser::Collector, "when collecting exported resources", :if =>
       @compiler.add_resource(@scope, local)
 
       expect { @collector.evaluate }.
-        to raise_error Puppet::ParseError, /exists with the type and title/
+        to raise_error Puppet::ParseError, /A duplicate resource was found while collecting exported resources/
     end
 
     it "should ignore exported resources that match already-collected resources" do

data/spec/unit/parser/compiler_spec.rb

@@ -646,7 +646,7 @@ describe Puppet::Parser::Compiler do
       @node.classes = klass
       klass = Puppet::Resource::Type.new(:hostclass, 'foo', :arguments => {})
       @compiler.topscope.known_resource_types.add klass
-      lambda { @compiler.compile }.should raise_error(Puppet::ParseError, "Invalid parameter 3")
+      lambda { @compiler.compile }.should raise_error(Puppet::ParseError, "Invalid parameter 3 on Class[Foo]")
     end
 
     it "should ensure class is in catalog without params" do

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

@@ -110,6 +110,10 @@ describe "the generate function" do
     File.delete(command) if Puppet::FileSystem.exist?(command)
   end
 
+  it "returns the output as a String" do
+    scope.function_generate([command]).class.should == String
+  end
+
   it "should call generator with no arguments" do
     scope.function_generate([command]).should == "a- b-\n"
   end

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

@@ -276,10 +276,26 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
       expect(evaluate(expr)).to be_the_type(types.host_class('apache'))
       expr = fqr('Class')[literal('apache')]
       expect(evaluate(expr)).to be_the_type(types.host_class('apache'))
+    end
 
+    it 'produces an array of Class when args are in an array' do
       # arguments are flattened
       expr = fqr('Class')[[fqn('apache')]]
-      expect(evaluate(expr)).to be_the_type(types.host_class('apache'))
+      expect(evaluate(expr)[0]).to be_the_type(types.host_class('apache'))
+    end
+
+    it 'produces undef for Class if arg is undef' do
+      # arguments are flattened
+      expr = fqr('Class')[nil]
+      expect(evaluate(expr)).to be_nil
+    end
+
+    it 'produces empty array for Class if arg is [undef]' do
+      # arguments are flattened
+      expr = fqr('Class')[[]]
+      expect(evaluate(expr)).to be_eql([])
+      expr = fqr('Class')[[nil]]
+      expect(evaluate(expr)).to be_eql([])
     end
 
     it 'raises error if access is to no keys' do
@@ -304,21 +320,28 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
       expect { evaluate(expr) }.to raise_error(/Illegal name/)
     end
 
-    it 'gives an error if an empty array is given as argument' do
-      expr = fqr('Class')[literal([])]
+    it 'gives an error if no keys are given as argument' do
+      expr = fqr('Class')[]
       expect {evaluate(expr)}.to raise_error(/Evaluation Error: Class\[\] accepts 1 or more arguments. Got 0/)
     end
 
+    it 'produces an empty array if the keys reduce to empty array' do
+      expr = fqr('Class')[literal([[],[]])]
+      expect(evaluate(expr)).to be_eql([])
+    end
+
     # Resource
     it 'produces a specific resource type from Resource[type]' do
       expr = fqr('Resource')[fqr('File')]
       expect(evaluate(expr)).to be_the_type(types.resource('File'))
       expr = fqr('Resource')[literal('File')]
       expect(evaluate(expr)).to be_the_type(types.resource('File'))
+    end
 
+    it 'does not allow the type to be specified in an array' do
       # arguments are flattened
       expr = fqr('Resource')[[fqr('File')]]
-      expect(evaluate(expr)).to be_the_type(types.resource('File'))
+      expect{evaluate(expr)}.to raise_error(Puppet::ParseError, /must be a resource type or a String/)
     end
 
     it 'produces a specific resource reference type from File[title]' do
@@ -340,14 +363,30 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
       expect(result[1]).to be_the_type(types.resource('File', 'y'))
     end
 
-    it 'gives an error if an empty array is given as argument' do
-      expr = fqr('Resource')[literal([])]
-      expect {evaluate(expr)}.to raise_error(/Evaluation Error: Resource\[\] accepts 1 to 2 arguments. Got 0/)
+    it 'produces undef for Resource if arg is undef' do
+      # arguments are flattened
+      expr = fqr('File')[nil]
+      expect(evaluate(expr)).to be_nil
+    end
+
+    it 'gives an error if no keys are given as argument to Resource' do
+      expr = fqr('Resource')[]
+      expect {evaluate(expr)}.to raise_error(/Evaluation Error: Resource\[\] accepts 1 or more arguments. Got 0/)
+    end
+
+    it 'produces an empty array if the type is given, and keys reduce to empty array for Resource' do
+      expr = fqr('Resource')[fqr('File'),literal([[],[]])]
+      expect(evaluate(expr)).to be_eql([])
+    end
+
+    it 'gives an error i no keys are given as argument to a specific Resource type' do
+      expr = fqr('File')[]
+      expect {evaluate(expr)}.to raise_error(/Evaluation Error: File\[\] accepts 1 or more arguments. Got 0/)
     end
 
-    it 'gives an error if an empty array is given as argument' do
-      expr = fqr('File')[literal([])]
-      expect {evaluate(expr)}.to raise_error(/Evaluation Error: File\[\] accepts 1 argument. Got 0/)
+    it 'produces an empty array if the keys reduce to empty array for a specific Resource tyoe' do
+      expr = fqr('File')[literal([[],[]])]
+      expect(evaluate(expr)).to be_eql([])
     end
 
     it 'gives an error if resource is not found' do
@@ -389,7 +428,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
     end
 
     failure_message_for_should do |actual|
-      "expected #{calc.string(type)}, but was #{calc.string(actual)}"
+      "expected #{type.to_s}, but was #{actual.to_s}"
     end
   end
 

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

@@ -181,6 +181,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "'1' < 1.1"      => true,
       "1.0 == 1 "      => true,
       "1.0 < 2  "      => true,
+      "1.0 < 'a'"      => true,
       "'1.0' < 1.1"    => true,
       "'1.0' < 'a'"    => true,
       "'1.0' < '' "    => true,
@@ -659,6 +660,9 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
         "notify { id: message=>explicit} Notify[id][message]"                   => "explicit",
         "Notify { message=>by_default} notify {foo:} Notify[foo][message]"      => "by_default",
         "notify {foo:} Notify[foo]{message =>by_override} Notify[foo][message]" => "by_override",
+        "notify { foo: tag => evoe} Notify[foo][tag]"                           => "evoe",
+        # Does not produce the defaults for tag
+        "notify { foo: } Notify[foo][tag]"                                      => nil,
       }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
@@ -669,6 +673,9 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       {
         "notify { xid: message=>explicit} Notify[id][message]"  => /Resource not found/,
         "notify { id: message=>explicit} Notify[id][mustard]"   => /does not have a parameter called 'mustard'/,
+        # NOTE: these meta-esque parameters are not recognized as such
+        "notify { id: message=>explicit} Notify[id][title]"   => /does not have a parameter called 'title'/,
+        "notify { id: message=>explicit} Notify[id]['type']"   => /does not have a parameter called 'type'/,
       }.each do |source, result|
         it "should parse '#{source}' and raise error matching #{result}" do
           expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(result)
@@ -760,6 +767,10 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
           expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
         end
       end
+
+    it "provides location information on error in unparenthesized call logic" do
+    expect{parser.evaluate_string(scope, "include non_existing_class", __FILE__)}.to raise_error(Puppet::ParseError, /line 1\:1/)
+    end
   end
 
   context "When evaluator performs string interpolation" do
@@ -961,6 +972,20 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
   end
+  context "Handles Deprecations and Discontinuations" do
+    around(:each) do |example|
+      Puppet.override({:loaders => Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))}, 'test') do
+        example.run
+      end
+    end
+
+    it 'of import statements' do
+      source = "\nimport foo"
+      # Error references position 5 at the opening '{'
+      # Set file to nil to make it easier to match with line number (no file name in output)
+      expect { parser.evaluate_string(scope, source) }.to raise_error(/'import' has been discontinued.*line 2:1/)
+    end
+  end
 
   context "Detailed Error messages are reported" do
     it 'for illegal type references' do

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

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+require 'puppet/pops'
+require 'puppet/loaders'
+
+describe 'dependency loader' do
+  include PuppetSpec::Files
+
+  let(:static_loader) { Puppet::Pops::Loader::StaticLoader.new() }
+  let(:loaders) { Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, [])) }
+
+  describe 'FileBased module loader' do
+    it 'load something in global name space raises an error' do
+      module_dir = dir_containing('testmodule', {
+      'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
+        'foo.rb' => 'Puppet::Functions.create_function("foo") { def foo; end; }'
+      }}}}})
+
+      module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, loaders, 'testmodule', module_dir, 'test1')
+      dep_loader = Puppet::Pops::Loader::DependencyLoader.new(static_loader, 'test-dep', [module_loader])
+      expect do
+        dep_loader.load_typed(typed_name(:function, 'testmodule::foo')).value
+      end.to raise_error(ArgumentError, /produced mis-matched name, expected 'testmodule::foo', got foo/)
+    end
+
+    it 'can load something in a qualified name space' do
+      module_dir = dir_containing('testmodule', {
+      'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
+        'foo.rb' => 'Puppet::Functions.create_function("testmodule::foo") { def foo; end; }'
+      }}}}})
+      module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, loaders, 'testmodule', module_dir, 'test1')
+      dep_loader = Puppet::Pops::Loader::DependencyLoader.new(static_loader, 'test-dep', [module_loader])
+
+      function = dep_loader.load_typed(typed_name(:function, 'testmodule::foo')).value
+
+      expect(function.class.name).to eq('testmodule::foo')
+      expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
+    end
+  end
+
+  def typed_name(type, name)
+    Puppet::Pops::Loader::Loader::TypedName.new(type, name)
+  end
+end

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

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+require 'puppet/pops'
+require 'puppet/loaders'
+
+describe 'loader paths' do
+  include PuppetSpec::Files
+  before(:each) { Puppet[:biff] = true }
+
+  let(:static_loader) { Puppet::Pops::Loader::StaticLoader.new() }
+  let(:unused_loaders) { nil }
+
+  describe 'the relative_path_for_types method' do
+    it 'produces paths to load in precendence order' do
+      module_dir = dir_containing('testmodule', {
+        'functions' => {},
+        'lib' => {
+          'puppet' => {
+            'functions' => {},
+            'parser' => {
+              'functions' => {},
+            }
+          }}})
+      module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, unused_loaders, 'testmodule', module_dir, 'test1')
+
+      effective_paths = Puppet::Pops::Loader::LoaderPaths.relative_paths_for_type(:function, module_loader)
+
+      expect(effective_paths.collect(&:generic_path)).to eq([
+        File.join(module_dir, 'lib', 'puppet', 'functions'), # 4x functions
+        File.join(module_dir, 'lib', 'puppet','parser', 'functions') # 3x functions
+      ])
+    end
+
+    it 'module loader has smart-paths that prunes unavailable paths' do
+      module_dir = dir_containing('testmodule', {'lib' => {'puppet' => {'functions' => {'foo.rb' => 'Puppet::Functions.create_function("testmodule::foo") { def foo; end; }' }}}})
+      module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, unused_loaders, 'testmodule', module_dir, 'test1')
+
+      effective_paths = module_loader.smart_paths.effective_paths(:function)
+
+      expect(effective_paths.size).to be_eql(1)
+      expect(effective_paths[0].generic_path).to be_eql(File.join(module_dir, 'lib', 'puppet', 'functions'))
+      expect(module_loader.path_index.size).to be_eql(1)
+      expect(module_loader.path_index.include?(File.join(module_dir, 'lib', 'puppet', 'functions', 'foo.rb'))).to be(true)
+    end
+
+    it 'all function smart-paths produces entries if they exist' do
+      module_dir = dir_containing('testmodule', {
+        'lib' => {
+          'puppet' => {
+            'functions' => {'foo4x.rb' => 'ignored in this test'},
+            'parser' => {
+              'functions' => {'foo3x.rb' => 'ignored in this test'},
+            }
+          }}})
+      module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, unused_loaders, 'testmodule', module_dir, 'test1')
+
+      effective_paths = module_loader.smart_paths.effective_paths(:function)
+
+      expect(effective_paths.size).to eq(2)
+      expect(module_loader.path_index.size).to eq(2)
+      path_index = module_loader.path_index
+      expect(path_index.include?(File.join(module_dir, 'lib', 'puppet', 'functions', 'foo4x.rb'))).to eq(true)
+      expect(path_index.include?(File.join(module_dir, 'lib', 'puppet', 'parser', 'functions', 'foo3x.rb'))).to eq(true)
+    end
+  end
+end