puppet 4.3.2-x64-mingw32 → 4.4.0-x64-mingw32

data/spec/unit/data_providers/hiera_interpolation_spec.rb

@@ -0,0 +1,57 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet'
+require 'puppet/data_providers/hiera_config'
+require 'puppet/data_providers/hiera_interpolate'
+
+describe "Puppet::DataProviders::HieraInterpolate" do
+
+  let(:interpolator) { Class.new { include Puppet::DataProviders::HieraInterpolate }.new }
+  let(:scope) { {} }
+  let(:lookup_invocation) { Puppet::Pops::Lookup::Invocation.new(scope, {}, {}, nil) }
+
+  context 'when interpolating nested data' do
+    let(:nested_hash) { { 'a' => { 'aa' => "%{alias('aaa')}" } } }
+
+    it 'produces a nested hash with arrays from nested aliases with hashes and arrays' do
+      Puppet::Pops::Lookup.expects(:lookup).with('aaa', nil, '', true, nil, lookup_invocation).returns({ 'b' => { 'bb' => "%{alias('bbb')}" } })
+      Puppet::Pops::Lookup.expects(:lookup).with('bbb', nil, '', true, nil, lookup_invocation).returns([ "%{alias('ccc')}" ])
+      Puppet::Pops::Lookup.expects(:lookup).with('ccc', nil, '', true, nil, lookup_invocation).returns('text')
+      expect(interpolator.interpolate(nested_hash, lookup_invocation, true)).to eq('a'=>{'aa'=>{'b'=>{'bb'=>['text']}}})
+    end
+  end
+
+  context 'when there are empty interpolations %{} in data' do
+
+    let(:empty_interpolation) {'clown%{}shoe'}
+    let(:empty_interpolation_as_escape) {'clown%%{}{shoe}s'}
+    let(:only_empty_interpolation) {'%{}'}
+    let(:empty_namespace) {'%{::}'}
+    let(:whitespace1) {'%{ :: }'}
+    let(:whitespace2) {'%{   }'}
+
+    it 'should produce an empty string for the interpolation' do
+      expect(interpolator.interpolate(empty_interpolation, lookup_invocation, true)).to eq('clownshoe')
+    end
+
+    it 'the empty interpolation can be used as an escape mechanism' do
+      expect(interpolator.interpolate(empty_interpolation_as_escape, lookup_invocation, true)).to eq('clown%{shoe}s')
+    end
+
+    it 'the value can consist of only an empty escape' do
+      expect(interpolator.interpolate(only_empty_interpolation, lookup_invocation, true)).to eq('')
+    end
+
+    it 'the value can consist of an empty namespace %{::}' do
+      expect(interpolator.interpolate(empty_namespace, lookup_invocation, true)).to eq('')
+    end
+
+    it 'the value can consist of whitespace %{ :: }' do
+      expect(interpolator.interpolate(whitespace1, lookup_invocation, true)).to eq('')
+    end
+
+    it 'the value can consist of whitespace %{  }' do
+      expect(interpolator.interpolate(whitespace2, lookup_invocation, true)).to eq('')
+    end
+  end
+end

data/spec/unit/defaults_spec.rb

@@ -71,4 +71,19 @@ describe "Defaults" do
     end
 
   end
+
+  describe 'supported_checksum_types' do
+    it 'should default to md5,sha256' do
+      expect(Puppet.settings[:supported_checksum_types]).to eq(['md5', 'sha256'])
+    end
+
+    it 'should raise an error on an unsupported checksum type' do
+      expect { Puppet.settings[:supported_checksum_types] = ['md5', 'foo'] }.to raise_exception ArgumentError, 'Unrecognized checksum types ["foo"] are not supported. Valid values are ["md5", "md5lite", "sha256", "sha256lite", "sha1", "sha1lite", "mtime", "ctime"].'
+    end
+
+    it 'should not raise an error on setting a valid list of checksum types' do
+      Puppet.settings[:supported_checksum_types] = ['sha256', 'md5lite', 'mtime']
+      expect(Puppet.settings[:supported_checksum_types]).to eq(['sha256', 'md5lite', 'mtime'])
+    end
+  end
 end

data/spec/unit/environments_spec.rb

@@ -121,6 +121,7 @@ describe Puppet::Environments do
 manifest=#{manifestdir}
 modulepath=#{modulepath.join(File::PATH_SEPARATOR)}
 config_version=/some/script
+static_catalogs=false
         EOF
       end
 
@@ -156,6 +157,17 @@ config_version=/some/script
         end
       end
 
+      it "reads static_catalogs setting" do
+        loader_from(:filesystem => [envdir, manifestdir, modulepath].flatten,
+                    :directory => envdir) do |loader|
+          expect(loader.get("env1")).to environment(:env1).
+            with_manifest(manifestdir.path).
+            with_modulepath(modulepath.map(&:path)).
+            with_config_version(File.expand_path('/some/script')).
+            with_static_catalogs(false)
+        end
+      end
+
       it "accepts an empty environment.conf without warning" do
         content = nil
 
@@ -176,7 +188,8 @@ config_version=/some/script
           expect(loader.get("env1")).to environment(:env1).
             with_manifest("#{FS.path_string(envdir)}/env1/manifests").
             with_modulepath(["#{FS.path_string(envdir)}/env1/modules", global_path_location]).
-            with_config_version(nil)
+            with_config_version(nil).
+            with_static_catalogs(true)
         end
 
         expect(@logs).to be_empty
@@ -386,6 +399,7 @@ config_version=$vardir/random/scripts
       expect(conf.modulepath).to eq('')
       expect(conf.manifest).to eq(:no_manifest)
       expect(conf.config_version).to be_nil
+      expect(conf.static_catalogs).to eq(true)
     end
 
     it "returns nil if you request a configuration from an env that doesn't exist" do
@@ -547,7 +561,8 @@ config_version=$vardir/random/scripts
         (!@manifest || @manifest == env.manifest) &&
         (!@modulepath || @modulepath == env.modulepath) &&
         (!@full_modulepath || @full_modulepath == env.full_modulepath) &&
-        (!@config_version || @config_version == env.config_version)
+        (!@config_version || @config_version == env.config_version) &&
+        (!@static_catalogs || @static_catalogs == env.static_catalogs?)
     end
 
     chain :with_manifest do |manifest|
@@ -566,16 +581,21 @@ config_version=$vardir/random/scripts
       @config_version = config_version
     end
 
+    chain :with_static_catalogs do |static_catalogs|
+      @static_catalogs = static_catalogs
+    end
+
     description do
       "environment #{expected}" +
         (@manifest ? " with manifest #{@manifest}" : "") +
         (@modulepath ? " with modulepath [#{@modulepath.join(', ')}]" : "") +
         (@full_modulepath ? " with full_modulepath [#{@full_modulepath.join(', ')}]" : "") +
-        (@config_version ? " with config_version #{@config_version}" : "")
+        (@config_version ? " with config_version #{@config_version}" : "") +
+        (@static_catalogs ? " with static_catalogs #{@static_catalogs}" : "")
     end
 
     failure_message do |env|
-      "expected <#{env.name}: modulepath = [#{env.full_modulepath.join(', ')}], manifest = #{env.manifest}, config_version = #{env.config_version}> to be #{description}"
+      "expected <#{env.name}: modulepath = [#{env.full_modulepath.join(', ')}], manifest = #{env.manifest}, config_version = #{env.config_version}>, static_catalogs = #{env.static_catalogs?} to be #{description}"
     end
   end
 

data/spec/unit/face/parser_spec.rb

@@ -30,9 +30,25 @@ describe Puppet::Face[:parser, :current] do
       end
 
       it "runs error free when there are no validation errors" do
-        manifest = file_containing('site.pp', "notify { valid: }")
+        expect {
+            manifest = file_containing('site.pp', "notify { valid: }")
+            parser.validate(manifest)
+        }.to_not raise_error
+      end
+
+      it "runs error free when there is a puppet function in manifest being validated" do
+        expect {
+          manifest = file_containing('site.pp', "function valid() { 'valid' } notify{ valid(): }")
+          parser.validate(manifest)
+        }.to_not raise_error
+      end
 
-        parser.validate(manifest)
+      it "runs error free when there is a type alias in a manifest that requires type resolution" do
+        expect {
+          manifest = file_containing('site.pp',
+            "type A = String; type B = Array[A]; function valid(B $x) { $x } notify{ valid([valid]): }")
+          parser.validate(manifest)
+        }.to_not raise_error
       end
 
       it "reports missing files" do
@@ -98,6 +114,31 @@ describe Puppet::Face[:parser, :current] do
       expect(@logs[0].message).to eq("Syntax error at end of file")
       expect(@logs[0].level).to eq(:err)
     end
+
+    it "logs an error if the input begins with a UTF-8 BOM (Byte Order Mark)" do
+      utf8_bom_manifest = file_containing('utf8_bom.pp', "\uFEFFnotice hi")
+
+      output = parser.dump(utf8_bom_manifest)
+
+      expect(output).to eq("")
+      expect(@logs[1].message).to eq("Illegal UTF-8 Byte Order mark at beginning of input: [EF BB BF] - remove these from the puppet source")
+      expect(@logs[1].level).to eq(:err)
+    end
+
+    it "runs error free when there is a puppet function in manifest being dumped" do
+      expect {
+        manifest = file_containing('site.pp', "function valid() { 'valid' } notify{ valid(): }")
+        parser.dump(manifest)
+      }.to_not raise_error
+    end
+
+    it "runs error free when there is a type alias in a manifest that requires type resolution" do
+      expect {
+        manifest = file_containing('site.pp',
+          "type A = String; type B = Array[A]; function valid(B $x) { $x } notify{ valid([valid]): }")
+        parser.dump(manifest)
+      }.to_not raise_error
+    end
   end
 
   def from_an_interactive_terminal

data/spec/unit/file_serving/http_metadata_spec.rb

@@ -0,0 +1,85 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/file_serving/http_metadata'
+require 'matchers/json'
+require 'net/http'
+require 'digest'
+
+describe Puppet::FileServing::HttpMetadata do
+  let(:foobar) { File.expand_path('/foo/bar') }
+
+  it "should be a subclass of Metadata" do
+    expect( described_class.superclass ).to be Puppet::FileServing::Metadata
+  end
+
+  describe "when initializing" do
+    let(:http_response) { Net::HTTPOK.new(1.0, '200', 'OK') }
+
+    it "can be instantiated from a HTTP response object" do
+      expect( described_class.new(http_response) ).to_not be_nil
+    end
+
+    it "represents a plain file" do
+      expect( described_class.new(http_response).ftype ).to eq 'file'
+    end
+
+    it "carries no information on owner, group and mode" do
+      metadata = described_class.new(http_response)
+      expect( metadata.owner ).to be_nil
+      expect( metadata.group ).to be_nil
+      expect( metadata.mode ).to be_nil
+    end
+
+    context "with no Last-Modified or Content-MD5 header from the server" do
+      before do
+        http_response.stubs(:[]).with('last-modified').returns nil
+        http_response.stubs(:[]).with('content-md5').returns nil
+      end
+
+      it "should use :mtime as the checksum type, based on current time" do
+        # Stringifying Time.now does some rounding; do so here so we don't end up with a time
+        # that's greater than the stringified version returned by collect.
+        time = Time.parse(Time.now.to_s)
+        metadata = described_class.new(http_response)
+        metadata.collect
+        expect( metadata.checksum_type ).to eq :mtime
+        checksum = metadata.checksum
+        expect( checksum[0...7] ).to eq '{mtime}'
+        expect( Time.parse(checksum[7..-1]) ).to be >= time
+      end
+    end
+
+    context "with a Last-Modified header from the server" do
+      let(:time) { Time.now.utc }
+      before do
+        http_response.stubs(:[]).with('content-md5').returns nil
+      end
+
+      it "should use :mtime as the checksum type, based on Last-Modified" do
+        # HTTP uses "GMT" not "UTC"
+        http_response.stubs(:[]).with('last-modified').returns(time.strftime("%a, %d %b %Y %T GMT"))
+        metadata = described_class.new(http_response)
+        metadata.collect
+        expect( metadata.checksum_type ).to eq :mtime
+        expect( metadata.checksum ).to eq "{mtime}#{time.to_time}"
+      end
+    end
+
+    context "with a Content-MD5 header being received" do
+      let(:input) { Time.now.to_s }
+      let(:base64) { Digest::MD5.new.base64digest input }
+      let(:hex) { Digest::MD5.new.hexdigest input }
+      before do
+        http_response.stubs(:[]).with('last-modified').returns nil
+        http_response.stubs(:[]).with('content-md5').returns base64
+      end
+
+      it "should use the md5 checksum" do
+        metadata = described_class.new(http_response)
+        metadata.collect
+        expect( metadata.checksum_type ).to eq :md5
+        expect( metadata.checksum ).to eq "{md5}#{hex}"
+      end
+    end
+  end
+end

data/spec/unit/file_serving/metadata_spec.rb

@@ -76,6 +76,45 @@ describe Puppet::FileServing::Metadata do
     it "should pass the checksum in the hash verbatim as the checksum's value" do
       expect(metadata.to_data_hash['checksum']['value']).to eq(metadata.checksum)
     end
+
+    describe "when a source and content_uri are set" do
+      before do
+        metadata.source = '/foo'
+        metadata.content_uri = 'puppet:///foo'
+      end
+
+      it "the data should include the path, relative_path, links, owner, group, mode, checksum, type, destination, source, and content_uri" do
+        expect(metadata.to_data_hash.keys.sort).to eq(%w{ path relative_path links owner group mode checksum type destination source content_uri }.sort)
+      end
+
+      it "should pass the source in the hash verbatim" do
+        expect(metadata.to_data_hash['source']).to eq(metadata.source)
+      end
+
+      it "should pass the content_uri in the hash verbatim" do
+        expect(metadata.to_data_hash['content_uri']).to eq(metadata.content_uri)
+      end
+    end
+
+    describe "when assigning a content_uri" do
+      it "should fail if uri is invalid" do
+        expect { metadata.content_uri = '://' }.to raise_error ArgumentError, /Could not understand URI :\/\//
+      end
+
+      it "should accept characters that require percent-encoding" do
+        uri = 'puppet:///modules/foo/files/ %:?#[]@!$&\'()*+,;='
+        metadata.content_uri = uri
+        expect(metadata.content_uri).to eq(uri)
+      end
+
+      it "should fail if uri is opaque" do
+        expect { metadata.content_uri = 'scheme:www.example.com' }.to raise_error ArgumentError, "Cannot use opaque URLs 'scheme:www.example.com'"
+      end
+
+      it "should fail if uri is not a puppet scheme" do
+        expect { metadata.content_uri = 'http://www.example.com' }.to raise_error ArgumentError, "Must use URLs of type puppet as content URI"
+      end
+    end
   end
 end
 
@@ -135,6 +174,17 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
         it "should validate against the schema" do
           expect(metadata.to_pson).to validate_against('api/schemas/file_metadata.json')
         end
+
+        describe "when a source and content_uri are set" do
+          before do
+            metadata.source = '/foo'
+            metadata.content_uri = 'puppet:///foo'
+          end
+
+          it "should validate against the schema" do
+            expect(metadata.to_pson).to validate_against('api/schemas/file_metadata.json')
+          end
+        end
       end
 
       describe "when managing directories" do

data/spec/unit/file_serving/terminus_selector_spec.rb

@@ -22,8 +22,18 @@ describe Puppet::FileServing::TerminusSelector do
       expect(@object.select(@request)).to eq(:file)
     end
 
-    it "should fail when a protocol other than :puppet or :file is used" do
-      @request.stubs(:protocol).returns "http"
+    it "should return :http if the URI protocol is set to 'http'" do
+      @request.expects(:protocol).returns "http"
+      expect(@object.select(@request)).to eq :http
+    end
+
+    it "should return :http if the URI protocol is set to 'https'" do
+      @request.expects(:protocol).returns "https"
+      expect(@object.select(@request)).to eq :http
+    end
+
+    it "should fail when a protocol other than :puppet, :http(s) or :file is used" do
+      @request.stubs(:protocol).returns "ftp"
       expect { @object.select(@request) }.to raise_error(ArgumentError)
     end
 

data/spec/unit/file_system_spec.rb

@@ -134,6 +134,32 @@ describe "Puppet::FileSystem" do
     end
   end
 
+  context "read should allow an encoding to be specified" do
+    # First line of Rune version of Rune poem at http://www.columbia.edu/~fdc/utf8/
+    # characters chosen since they will not parse on Windows with codepage 437 or 1252
+    # Section 3.2.1.3 of Ruby spec guarantees that \u strings are encoded as UTF-8
+    let (:rune_utf8) { "\u16A0\u16C7\u16BB" } # 'ᚠᛇᚻ'
+
+    it "and should read a UTF8 file properly" do
+      temp_file = file_containing('utf8.txt', rune_utf8)
+
+      contents = Puppet::FileSystem.read(temp_file, :encoding => 'utf-8')
+
+      expect(contents.encoding).to eq(Encoding::UTF_8)
+      expect(contents).to eq(rune_utf8)
+    end
+
+    it "does not strip the UTF8 BOM (Byte Order Mark) if present in a file" do
+      bom = "\uFEFF"
+
+      temp_file = file_containing('utf8bom.txt', "#{bom}#{rune_utf8}")
+      contents = Puppet::FileSystem.read(temp_file, :encoding => 'utf-8')
+
+      expect(contents.encoding).to eq(Encoding::UTF_8)
+      expect(contents).to eq("#{bom}#{rune_utf8}")
+    end
+  end
+
   describe "symlink",
     :if => ! Puppet.features.manages_symlinks? &&
     Puppet.features.microsoft_windows? do

data/spec/unit/functions/assert_type_spec.rb

@@ -1,8 +1,11 @@
 require 'spec_helper'
 require 'puppet/pops'
 require 'puppet/loaders'
+require 'puppet_spec/compiler'
 
 describe 'the assert_type function' do
+  include PuppetSpec::Compiler
+
   after(:all) { Puppet::Pops::Loaders.clear }
 
   let(:loaders) { Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, [])) }
@@ -19,13 +22,13 @@ describe 'the assert_type function' do
   it 'asserts non compliant type by raising an error' do
     expect do
       func.call({}, type(Integer), 'hello world')
-    end.to raise_error(Puppet::Pops::Types::TypeAssertionError, /does not match actual/)
+    end.to raise_error(Puppet::Pops::Types::TypeAssertionError, /expected an Integer value, got String/)
   end
 
   it 'checks that first argument is a type' do
     expect do
       func.call({}, 10, 10)
-    end.to raise_error(ArgumentError, "'assert_type' expected one of:
+    end.to raise_error(ArgumentError, "'assert_type' expects one of:
   (Type type, Any value, Callable[Type, Type] block?)
     rejected: parameter 'type' expects a Type value, got Integer
   (String type_string, Any value, Callable[Type, Type] block?)
@@ -52,4 +55,35 @@ describe 'the assert_type function' do
   def type(type_ref)
     Puppet::Pops::Types::TypeFactory.type_of(type_ref)
   end
+
+  it 'can validate a resource type' do
+    expect(eval_and_collect_notices("assert_type(Type[Resource], File['/tmp/test']) notice('ok')")).to eq(['ok'])
+  end
+
+  it 'can validate a type alias' do
+    code = <<-CODE
+      type UnprivilegedPort = Integer[1024,65537]
+      assert_type(UnprivilegedPort, 5432)
+      notice('ok')
+    CODE
+    expect(eval_and_collect_notices(code)).to eq(['ok'])
+  end
+
+  it 'can validate a type alias passed as a String' do
+    code = <<-CODE
+      type UnprivilegedPort = Integer[1024,65537]
+      assert_type('UnprivilegedPort', 5432)
+      notice('ok')
+    CODE
+    expect(eval_and_collect_notices(code)).to eq(['ok'])
+  end
+
+  it 'can validate and fail using a type alias' do
+    code = <<-CODE
+      type UnprivilegedPort = Integer[1024,65537]
+      assert_type(UnprivilegedPort, 345)
+      notice('ok')
+    CODE
+    expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /expected an UnprivilegedPort = Integer\[1024, 65537\] value, got Integer\[345, 345\]/)
+  end
 end