puppet 4.8.2 → 4.9.0

data/spec/unit/functions/new_spec.rb

@@ -533,7 +533,7 @@ describe 'the new function' do
     { []            => 'Notify[Array[Unit], []]',
       [true]        => 'Notify[Array[Boolean], [true]]',
       {'a'=>true, 'b' => false}   => 'Notify[Array[Array[Scalar]], [[a, true], [b, false]]]',
-      'abc'         => 'Notify[Array[String], [a, b, c]]',
+      'abc'         => 'Notify[Array[String[1, 1]], [a, b, c]]',
       3             => 'Notify[Array[Integer], [0, 1, 2]]',
     }.each do |input, result|
       it "produces #{result} when given the value #{input.inspect} and wrap is not given" do
@@ -591,7 +591,7 @@ describe 'the new function' do
   end
 
   context 'when invoked on Tuple' do
-    { 'abc'         => 'Notify[Array[String], [a, b, c]]',
+    { 'abc'         => 'Notify[Array[String[1, 1]], [a, b, c]]',
       3             => 'Notify[Array[Integer], [0, 1, 2]]',
     }.each do |input, result|
       it "produces #{result} when given the value #{input.inspect} and wrap is not given" do
@@ -617,7 +617,7 @@ describe 'the new function' do
       {'a'=>true}   => 'Notify[Hash[String, Boolean], {a => true}]',
       [1,2,3,4]     => 'Notify[Hash[Integer, Integer], {1 => 2, 3 => 4}]',
       [[1,2],[3,4]] => 'Notify[Hash[Integer, Integer], {1 => 2, 3 => 4}]',
-      'abcd'        => 'Notify[Hash[String, String], {a => b, c => d}]',
+      'abcd'        => 'Notify[Hash[String[1, 1], String[1, 1]], {a => b, c => d}]',
       4             => 'Notify[Hash[Integer, Integer], {0 => 1, 2 => 3}]',
 
     }.each do |input, result|

data/spec/unit/graph/rb_tree_map_spec.rb

@@ -376,7 +376,7 @@ describe Puppet::Graph::RbTreeMap do
   describe "#each" do
     it "should yield each pair in the tree in order if a block is provided" do
       # Insert in reverse to demonstrate they aren't being yielded in insertion order
-      (1..5).to_a.reverse.each {|i| subject[i] = i.to_s}
+      (1..5).to_a.reverse_each {|i| subject[i] = i.to_s}
 
       nodes = []
       subject.each do |key,value|

data/spec/unit/graph/simple_graph_spec.rb

@@ -430,7 +430,7 @@ describe Puppet::Graph::SimpleGraph do
     end
 
     it "should write a dot file based on the passed name" do
-      File.expects(:open).with(@file, "w").yields(stub("file", :puts => nil))
+      File.expects(:open).with(@file, "w:UTF-8").yields(stub("file", :puts => nil))
       @graph.expects(:to_dot).with("name" => @name.to_s.capitalize)
       Puppet[:graph] = true
       @graph.write_graph(@name)

data/spec/unit/hiera/scope_spec.rb

@@ -74,14 +74,14 @@ describe Hiera::Scope do
     end
   end
 
-  describe "#include?" do
+  describe "#exist?" do
     it "should correctly report missing data" do
       real["nil_value"] = nil
       real["blank_value"] = ""
 
-      expect(scope.include?("nil_value")).to eq(true)
-      expect(scope.include?("blank_value")).to eq(true)
-      expect(scope.include?("missing_value")).to eq(false)
+      expect(scope.exist?("nil_value")).to eq(true)
+      expect(scope.exist?("blank_value")).to eq(true)
+      expect(scope.exist?("missing_value")).to eq(false)
     end
 
     it "should always return true for calling_class and calling_module" do

data/spec/unit/indirector/request_spec.rb

@@ -140,6 +140,15 @@ describe Puppet::Indirector::Request do
         expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff with spaces", nil).key).to eq("stuff with spaces")
       end
 
+      it "should set the request key to the unescaped path from the URI, in UTF-8 encoding" do
+        path = "\u4e07"
+        uri = "http://host/#{path}"
+        request = Puppet::Indirector::Request.new(:ind, :method, uri, nil)
+
+        expect(request.key).to eq(path)
+        expect(request.key.encoding).to eq(Encoding::UTF_8)
+      end
+
       it "should set the :uri attribute to the full URI" do
         expect(Puppet::Indirector::Request.new(:ind, :method, "http:///a/path/stu ff", nil).uri).to eq('http:///a/path/stu ff')
       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'/)

data/spec/unit/module_spec.rb

@@ -730,7 +730,7 @@ describe Puppet::Module do
     it "should properly parse utf-8 contents" do
       rune_utf8 = "\u16A0\u16C7\u16BB" # ᚠᛇᚻ
       metadata_json = tmpfile('metadata.json')
-      File.open(metadata_json, 'w') do |file|
+      File.open(metadata_json, 'w:UTF-8') do |file|
         file.puts <<-EOF
   {
     "license" : "GPL2",

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

@@ -358,6 +358,13 @@ symlinkfile
   end
 
   context 'with metadata.json' do
+    # different UTF-8 widths
+    # 1-byte A
+    # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+    # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+    # 4-byte 𠜎 - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+    MIXED_UTF8 = "A\u06FF\u16A0\u{2070E}" # Aۿᚠ𠜎
+
     before :each do
       File.open(File.join(path, 'metadata.json'), 'w') do |f|
         f.puts({
@@ -366,7 +373,7 @@ symlinkfile
           "source" => "https://github.com/testing/#{module_name}",
           "author" => "testing",
           "license" => "Apache License Version 2.0",
-          "summary" => "Puppet testing module",
+          "summary" => "#{MIXED_UTF8}",
           "description" => "This module can be used for basic testing",
           "project_page" => "https://github.com/testing/#{module_name}"
         }.to_json)
@@ -393,6 +400,14 @@ symlinkfile
         builder.run
       }.to raise_error Puppet::ModuleTool::Errors::ModuleToolError, /symlinks/i
     end
+
+    it "writes UTF-8 metdata correctly" do
+      # file is written initially in before block, then by builders write_json method
+      builder.run
+      metadata_path = File.join(path, 'metadata.json')
+      summary = JSON.parse(Puppet::FileSystem.read(metadata_path, :encoding => Encoding::UTF_8))["summary"]
+      expect(summary).to eq(MIXED_UTF8)
+    end
   end
 
   context 'with metadata.json containing checksums' do

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

@@ -29,7 +29,7 @@ describe Puppet::ModuleTool::Applications::Installer do
   end
 
   before do
-    Semantic::Dependency.clear_sources
+    SemanticPuppet::Dependency.clear_sources
     installer = Puppet::ModuleTool::Applications::Installer.any_instance
     installer.stubs(:module_repository).returns(remote_source)
   end

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

@@ -27,7 +27,7 @@ describe Puppet::ModuleTool::Applications::Upgrader do
   end
 
   before do
-    Semantic::Dependency.clear_sources
+    SemanticPuppet::Dependency.clear_sources
     installer = Puppet::ModuleTool::Applications::Upgrader.any_instance
     installer.stubs(:module_repository).returns(remote_source)
   end

data/spec/unit/module_tool/installed_modules_spec.rb

@@ -19,21 +19,21 @@ describe Puppet::ModuleTool::InstalledModules do
   it 'works when given a semantic version' do
     mod = PuppetSpec::Modules.create('goodsemver', @modpath, :metadata => {:version => '1.2.3'})
     installed = described_class.new(@env)
-    expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(Semantic::Version.parse('1.2.3'))
+    expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(SemanticPuppet::Version.parse('1.2.3'))
   end
 
   it 'defaults when not given a semantic version' do
     mod = PuppetSpec::Modules.create('badsemver', @modpath, :metadata => {:version => 'banana'})
     Puppet.expects(:warning).with(regexp_matches(/Semantic Version/))
     installed = described_class.new(@env)
-    expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(Semantic::Version.parse('0.0.0'))
+    expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(SemanticPuppet::Version.parse('0.0.0'))
   end
 
   it 'defaults when not given a full semantic version' do
     mod = PuppetSpec::Modules.create('badsemver', @modpath, :metadata => {:version => '1.2'})
     Puppet.expects(:warning).with(regexp_matches(/Semantic Version/))
     installed = described_class.new(@env)
-    expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(Semantic::Version.parse('0.0.0'))
+    expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(SemanticPuppet::Version.parse('0.0.0'))
   end
 
   it 'still works if there is an invalid version in one of the modules' do
@@ -42,8 +42,8 @@ describe Puppet::ModuleTool::InstalledModules do
     mod3 = PuppetSpec::Modules.create('notquitesemver', @modpath, :metadata => {:version => '1.2'})
     Puppet.expects(:warning).with(regexp_matches(/Semantic Version/)).twice
     installed = described_class.new(@env)
-    expect(installed.modules["puppetlabs-#{mod1.name}"].version).to eq(Semantic::Version.parse('0.0.0'))
-    expect(installed.modules["puppetlabs-#{mod2.name}"].version).to eq(Semantic::Version.parse('1.2.3'))
-    expect(installed.modules["puppetlabs-#{mod3.name}"].version).to eq(Semantic::Version.parse('0.0.0'))
+    expect(installed.modules["puppetlabs-#{mod1.name}"].version).to eq(SemanticPuppet::Version.parse('0.0.0'))
+    expect(installed.modules["puppetlabs-#{mod2.name}"].version).to eq(SemanticPuppet::Version.parse('1.2.3'))
+    expect(installed.modules["puppetlabs-#{mod3.name}"].version).to eq(SemanticPuppet::Version.parse('0.0.0'))
   end
 end

data/spec/unit/module_tool_spec.rb

@@ -288,21 +288,21 @@ TREE
     it 'parses a dependency without a version range expression' do
       name, range, expr = subject.parse_module_dependency('source', 'name' => 'foo-bar')
       expect(name).to eql('foo-bar')
-      expect(range).to eql(Semantic::VersionRange.parse('>= 0.0.0'))
+      expect(range).to eql(SemanticPuppet::VersionRange.parse('>= 0.0.0'))
       expect(expr).to eql('>= 0.0.0')
     end
 
     it 'parses a dependency with a version range expression' do
       name, range, expr = subject.parse_module_dependency('source', 'name' => 'foo-bar', 'version_requirement' => '1.2.x')
       expect(name).to eql('foo-bar')
-      expect(range).to eql(Semantic::VersionRange.parse('1.2.x'))
+      expect(range).to eql(SemanticPuppet::VersionRange.parse('1.2.x'))
       expect(expr).to eql('1.2.x')
     end
 
     it 'does not raise an error on invalid version range expressions' do
       name, range, expr = subject.parse_module_dependency('source', 'name' => 'foo-bar', 'version_requirement' => 'nope')
       expect(name).to eql('foo-bar')
-      expect(range).to eql(Semantic::VersionRange::EMPTY_RANGE)
+      expect(range).to eql(SemanticPuppet::VersionRange::EMPTY_RANGE)
       expect(expr).to eql('nope')
     end
   end

data/spec/unit/network/http/connection_spec.rb

@@ -296,4 +296,14 @@ describe Puppet::Network::HTTP::Connection do
       expect(request['authorization']).to match(/^Basic/)
     end.returns(httpok)
   end
+
+  it "sets HTTP User-Agent header" do
+    puppet_ua = "Puppet/#{Puppet.version} Ruby/#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} (#{RUBY_PLATFORM})"
+
+    Net::HTTP.any_instance.expects(:request).with do |request|
+      expect(request['User-Agent']).to eq(puppet_ua)
+    end.returns(httpok)
+
+    subject.get('/path')
+  end
 end

data/spec/unit/network/http/webrick_spec.rb

@@ -136,7 +136,7 @@ describe Puppet::Network::HTTP::WEBrick do
       log = make_absolute("/master/log")
       Puppet[:masterhttplog] = log
 
-      File.expects(:open).with(log, "a+").returns @filehandle
+      File.expects(:open).with(log, "a+:UTF-8").returns @filehandle
 
       server.setup_logger
     end

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

@@ -492,13 +492,13 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
     it 'produces a NotUndef instance with String type when given a literal String' do
       type_expr = fqr('NotUndef')[literal('hey')]
       tf = Puppet::Pops::Types::TypeFactory
-      expect(evaluate(type_expr)).to be_the_type(tf.not_undef(tf.string(nil, 'hey')))
+      expect(evaluate(type_expr)).to be_the_type(tf.not_undef(tf.string('hey')))
     end
 
     it 'Produces Optional instance with String type when using a String argument' do
       type_expr = fqr('Optional')[literal('hey')]
       tf = Puppet::Pops::Types::TypeFactory
-      expect(evaluate(type_expr)).to be_the_type(tf.optional(tf.string(nil, 'hey')))
+      expect(evaluate(type_expr)).to be_the_type(tf.optional(tf.string('hey')))
     end
 
     # Type Type

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

@@ -26,27 +26,27 @@ describe 'when converting to 3.x' do
   end
 
   it 'does not convert a SemVer instance to string' do
-    v = Semantic::Version.parse('1.0.0')
+    v = SemanticPuppet::Version.parse('1.0.0')
     expect(converter.convert(v, {}, nil)).to equal(v)
   end
 
   it 'converts the symbol :undef to the undef value' do
-    v = Semantic::Version.parse('1.0.0')
+    v = SemanticPuppet::Version.parse('1.0.0')
     expect(converter.convert(:undef, {}, 'undef value')).to eql('undef value')
   end
 
   it 'converts the nil to the undef value' do
-    v = Semantic::Version.parse('1.0.0')
+    v = SemanticPuppet::Version.parse('1.0.0')
     expect(converter.convert(nil, {}, 'undef value')).to eql('undef value')
   end
 
   it 'does not convert a symbol nested in an array' do
-    v = Semantic::Version.parse('1.0.0')
+    v = SemanticPuppet::Version.parse('1.0.0')
     expect(converter.convert({'foo' => :undef}, {}, 'undef value')).to eql({'foo' => :undef})
   end
 
   it 'converts nil to :undef when nested in an array' do
-    v = Semantic::Version.parse('1.0.0')
+    v = SemanticPuppet::Version.parse('1.0.0')
     expect(converter.convert({'foo' => nil}, {}, 'undef value')).to eql({'foo' => :undef})
   end
 
@@ -56,12 +56,12 @@ describe 'when converting to 3.x' do
   end
 
   it 'does not convert a Version instance to string' do
-    v = Semantic::Version.parse('1.0.0')
+    v = SemanticPuppet::Version.parse('1.0.0')
     expect(converter.convert(v, {}, nil)).to equal(v)
   end
 
   it 'does not convert a VersionRange instance to string' do
-    v = Semantic::VersionRange.parse('>=1.0.0')
+    v = SemanticPuppet::VersionRange.parse('>=1.0.0')
     expect(converter.convert(v, {}, nil)).to equal(v)
   end
 
@@ -95,13 +95,13 @@ describe 'when converting to 3.x' do
     end
 
     it 'converts a Version instance to string' do
-      c = converter.convert(Semantic::Version.parse('1.0.0'), {}, nil)
+      c = converter.convert(SemanticPuppet::Version.parse('1.0.0'), {}, nil)
       expect(c).to be_a(String)
       expect(c).to eql('1.0.0')
     end
 
     it 'converts a VersionRange instance to string' do
-      c = converter.convert(Semantic::VersionRange.parse('>=1.0.0'), {}, nil)
+      c = converter.convert(SemanticPuppet::VersionRange.parse('>=1.0.0'), {}, nil)
       expect(c).to be_a(String)
       expect(c).to eql('>=1.0.0')
     end

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

@@ -0,0 +1,172 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+require 'puppet/pops'
+require 'puppet/loaders'
+
+describe 'Environment loader' do
+  include PuppetSpec::Files
+
+  let(:env_name) { 'spec' }
+  let(:code_dir) { Puppet[:environmentpath] }
+  let(:env_dir) { File.join(code_dir, env_name) }
+  let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_code_dir, env_name, 'modules')]) }
+  let(:populated_code_dir) do
+    dir_contained_in(code_dir, env_name => env_content)
+    PuppetSpec::Files.record_tmp(env_dir)
+    code_dir
+  end
+
+  let(:env_content) {
+    {
+      'lib' => {
+        'puppet' => {
+          'functions' => {
+            'ruby_foo.rb' => <<-RUBY.unindent,
+              Puppet::Functions.create_function(:ruby_foo) do
+                def ruby_foo()
+                  'ruby_foo'
+                end
+              end
+              RUBY
+            'environment' => {
+              'ruby_foo.rb' => <<-RUBY.unindent
+                Puppet::Functions.create_function(:'environment::ruby_foo') do
+                  def ruby_foo()
+                    'environment::ruby_foo'
+                  end
+                end
+                RUBY
+            },
+            'someother' => {
+              'ruby_foo.rb' => <<-RUBY.unindent
+                Puppet::Functions.create_function(:'someother::ruby_foo') do
+                  def ruby_foo()
+                    'someother::ruby_foo'
+                  end
+                end
+                RUBY
+            },
+          }
+        }
+      },
+      'functions' => {
+        'puppet_foo.pp' => <<-PUPPET.unindent,
+          function puppet_foo() {
+            'puppet_foo'
+          }
+          PUPPET
+        'environment' => {
+          'puppet_foo.pp' => <<-PUPPET.unindent,
+            function environment::puppet_foo() {
+              'environment::puppet_foo'
+            }
+            PUPPET
+        },
+        'someother' => {
+          'puppet_foo.pp' => <<-PUPPET.unindent,
+            function somether::puppet_foo() {
+              'someother::puppet_foo'
+            }
+            PUPPET
+        }
+      },
+      'types' => {
+        'footype.pp' => <<-PUPPET.unindent,
+          type FooType = Enum['foo', 'bar', 'baz']
+          PUPPET
+        'environment' => {
+          'footype.pp' => <<-PUPPET.unindent,
+            type Environment::FooType = Integer[0,9]
+            PUPPET
+        },
+        'someother' => {
+          'footype.pp' => <<-PUPPET.unindent,
+            type SomeOther::FooType = Float[0.0,9.0]
+            PUPPET
+        }
+      }
+    }
+  }
+
+  before(:each) do
+    Puppet.push_context(:loaders => Puppet::Pops::Loaders.new(env))
+  end
+
+  after(:each) do
+    Puppet.pop_context
+  end
+
+  def load_or_nil(type, name)
+    found = Puppet::Pops::Loaders.find_loader(nil).load_typed(Puppet::Pops::Loader::TypedName.new(type, name))
+    found.nil? ? nil : found.value
+  end
+
+  context 'loading a Ruby function' do
+    it 'loads from global name space' do
+      function = load_or_nil(:function, 'ruby_foo')
+      expect(function).not_to be_nil
+
+      expect(function.class.name).to eq('ruby_foo')
+      expect(function).to be_a(Puppet::Functions::Function)
+    end
+
+    it 'loads from environment name space' do
+      function = load_or_nil(:function, 'environment::ruby_foo')
+      expect(function).not_to be_nil
+
+      expect(function.class.name).to eq('environment::ruby_foo')
+      expect(function).to be_a(Puppet::Functions::Function)
+    end
+
+    it 'fails to load from namespaces other than global or environment' do
+      function = load_or_nil(:function, 'someother::ruby_foo')
+      expect(function).to be_nil
+    end
+  end
+
+  context 'loading a Puppet function' do
+    it 'loads from global name space' do
+      function = load_or_nil(:function, 'puppet_foo')
+      expect(function).not_to be_nil
+
+      expect(function.class.name).to eq('puppet_foo')
+      expect(function).to be_a(Puppet::Functions::PuppetFunction)
+    end
+
+    it 'loads from environment name space' do
+      function = load_or_nil(:function, 'environment::puppet_foo')
+      expect(function).not_to be_nil
+
+      expect(function.class.name).to eq('environment::puppet_foo')
+      expect(function).to be_a(Puppet::Functions::PuppetFunction)
+    end
+
+    it 'fails to load from namespaces other than global or environment' do
+      function = load_or_nil(:function, 'someother::puppet_foo')
+      expect(function).to be_nil
+    end
+  end
+
+  context 'loading a Puppet type' do
+    it 'loads from global name space' do
+      type = load_or_nil(:type, 'footype')
+      expect(type).not_to be_nil
+
+      expect(type).to be_a(Puppet::Pops::Types::PTypeAliasType)
+      expect(type.name).to eq('FooType')
+    end
+
+    it 'loads from environment name space' do
+      type = load_or_nil(:type, 'environment::footype')
+      expect(type).not_to be_nil
+
+      expect(type).to be_a(Puppet::Pops::Types::PTypeAliasType)
+      expect(type.name).to eq('Environment::FooType')
+    end
+
+    it 'fails to load from namespaces other than global or environment' do
+      type = load_or_nil(:type, 'someother::footype')
+      expect(type).to be_nil
+    end
+  end
+end