puppet 4.10.9 → 4.10.10

data/spec/unit/functions/defined_spec.rb

@@ -268,11 +268,11 @@ describe "the 'defined' function" do
   end
 
   it 'raises error if referencing undef' do
-    expect{func.call(@scope, nil)}.to raise_error(ArgumentError, /'defined' parameter 'vals' expects a value of type String or Type, got Undef/)
+    expect{func.call(@scope, nil)}.to raise_error(ArgumentError, /'defined' parameter 'vals' expects a value of type String, Type\[CatalogEntry\], or Type\[Type\], got Undef/)
   end
 
   it 'raises error if referencing a number' do
-    expect{func.call(@scope, 42)}.to raise_error(ArgumentError, /'defined' parameter 'vals' expects a value of type String or Type, got Integer/)
+    expect{func.call(@scope, 42)}.to raise_error(ArgumentError, /'defined' parameter 'vals' expects a value of type String, Type\[CatalogEntry\], or Type\[Type\], got Integer/)
   end
 
   it 'is false if referencing empty string' do

data/spec/unit/functions/lookup_spec.rb

@@ -842,6 +842,24 @@ describe "The lookup function" do
           end
         end
       end
+
+      context 'that contains an array with duplicates' do
+        let(:common_yaml) { <<-YAML.unindent }
+          a:
+           - alpha
+           - bravo
+           - charlie
+           - bravo
+          YAML
+
+        it 'retains the duplicates when using default merge strategy' do
+          expect(lookup('a')).to eql(%w(alpha bravo charlie bravo))
+        end
+
+        it 'does deduplification when using merge strategy "unique"' do
+          expect(lookup('a', :merge => 'unique')).to eql(%w(alpha bravo charlie))
+        end
+      end
     end
 
     context 'with lookup_options configured using patterns' do
@@ -1084,14 +1102,81 @@ describe "The lookup function" do
               glob_c: value glob_a
               YAML
             'b.yaml' => <<-YAML.unindent
-              glob_b:
-                c: value glob_b.c
-                d: value glob_b.d
+              glob_d:
+                a: value glob_d.a
+                b: value glob_d.b
             YAML
 
           }
         }
       end
+
+      it 'finds environment data using globs' do
+        expect(lookup('glob_a')).to eql('value glob_a')
+        expect(warnings).to be_empty
+      end
+
+      it 'finds environment data using interpolated globs' do
+        expect(lookup('glob_d.a')).to eql('value glob_d.a')
+        expect(warnings).to be_empty
+      end
+    end
+
+    context 'and an environment Hiera v5 configuration using uris' do
+      let(:env_hiera_yaml) do
+        <<-YAML.unindent
+        ---
+        version: 5
+        hierarchy:
+          - name: Uris
+            uris:
+              - "http://test.example.com"
+              - "/some/arbitrary/path"
+              - "urn:with:opaque:path"
+              - "dothis%20-f%20bar"
+            data_hash: mod::uri_test_func
+        YAML
+      end
+
+      let(:env_modules) do
+        {
+          'mod' => { 'lib' => { 'puppet' => { 'functions' => { 'mod' => { 'uri_test_func.rb' => <<-RUBY } } } } }
+            Puppet::Functions.create_function(:'mod::uri_test_func') do
+              dispatch :uri_test_func do
+                param 'Hash', :options
+                param 'Puppet::LookupContext', :context
+              end
+
+              def uri_test_func(options, context)
+                { 'uri' => [ options['uri'] ] }
+              end
+            end
+            RUBY
+        }
+      end
+
+      it 'The uris are propagated in the options hash' do
+        expect(lookup('uri', 'merge' => 'unique')).to eql(
+          %w(http://test.example.com /some/arbitrary/path urn:with:opaque:path dothis%20-f%20bar))
+        expect(warnings).to be_empty
+      end
+
+      context 'and a uri uses bad syntax' do
+        let(:env_hiera_yaml) do
+          <<-YAML.unindent
+        ---
+        version: 5
+        hierarchy:
+          - name: Uris
+            uri: "dothis -f bar"
+            data_hash: mod::uri_test_func
+          YAML
+        end
+
+        it 'an attempt to lookup raises InvalidURIError' do
+          expect{ lookup('uri', 'merge' => 'unique') }.to raise_error(/bad URI/)
+        end
+      end
     end
 
     context 'and an environment Hiera v5 configuration using mapped_paths' do

data/spec/unit/interface_spec.rb

@@ -126,6 +126,18 @@ describe Puppet::Interface do
     expect { subject[:foo, '0.0.1'] }.to raise_error Puppet::Error
   end
 
+  describe 'when raising NoMethodErrors' do
+    subject { described_class.new(:foo, '1.0.0') }
+
+    it 'includes the face name in the error message' do
+      expect { subject.boombaz }.to raise_error(NoMethodError, /#{subject.name}/)
+    end
+
+    it 'includes the face version in the error message' do
+      expect { subject.boombaz }.to raise_error(NoMethodError, /#{subject.version}/)
+    end
+  end
+
   it_should_behave_like "things that declare options" do
     def add_options_to(&block)
       subject.new(:with_options, '0.0.1', &block)

data/spec/unit/module_tool/tar/mini_spec.rb

@@ -8,10 +8,17 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
   let(:destfile)   { '/the/dest/file.tar.gz' }
   let(:minitar)    { described_class.new }
 
-  it "unpacks a tar file" do
-    unpacks_the_entry(:file_start, 'thefile')
+  class MockFileStatEntry
+    def initialize(mode = 0100)
+      @mode = mode
+    end
+  end
+
+  it "unpacks a tar file with correct permissions" do
+    entry = unpacks_the_entry(:file_start, 'thefile')
 
     minitar.unpack(sourcefile, destdir, 'uid')
+    expect(entry.instance_variable_get(:@mode)).to eq(0755)
   end
 
   it "does not allow an absolute path" do
@@ -41,20 +48,42 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
                      "Attempt to install file with an invalid path into \"#{File.expand_path('/the/thedir')}\" under \"#{destdir}\"")
   end
 
+  it "unpacks on Windows" do
+    unpacks_the_entry(:file_start, 'thefile', nil)
+
+    entry = minitar.unpack(sourcefile, destdir, 'uid')
+    # Windows does not use these permissions.
+    expect(entry.instance_variable_get(:@mode)).to eq(nil)
+  end
+
   it "packs a tar file" do
     writer = stub('GzipWriter')
 
     Zlib::GzipWriter.expects(:open).with(destfile).yields(writer)
-    Archive::Tar::Minitar.expects(:pack).with(sourcedir, writer)
+    stats = {:mode => 0222}
+    Archive::Tar::Minitar.expects(:pack).with(sourcedir, writer).yields(:file_start, 'abc', stats)
+
+    minitar.pack(sourcedir, destfile)
+  end
+
+  it "packs a tar file on Windows" do
+    writer = stub('GzipWriter')
+
+    Zlib::GzipWriter.expects(:open).with(destfile).yields(writer)
+    Archive::Tar::Minitar.expects(:pack).with(sourcedir, writer).
+        yields(:file_start, 'abc', {:entry => MockFileStatEntry.new(nil)})
 
     minitar.pack(sourcedir, destfile)
   end
 
-  def unpacks_the_entry(type, name)
+  def unpacks_the_entry(type, name, mode = 0100)
     reader = stub('GzipReader')
 
     Zlib::GzipReader.expects(:open).with(sourcefile).yields(reader)
     minitar.expects(:find_valid_files).with(reader).returns([name])
-    Archive::Tar::Minitar.expects(:unpack).with(reader, destdir, [name]).yields(type, name, nil)
+    entry = MockFileStatEntry.new(mode)
+    Archive::Tar::Minitar.expects(:unpack).with(reader, destdir, [name]).
+        yields(type, name, {:entry => entry})
+    entry
   end
 end

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

@@ -94,5 +94,27 @@ describe Puppet::Network::HTTP::Factory do
         expect(conn.read_timeout).to eq(120)
       end
     end
+
+    context 'source address' do
+      it 'defaults to system-defined' do
+        skip "Requires Ruby >= 2.0" unless RUBY_VERSION.to_i >= 2
+        conn = create_connection(site)
+
+        expect(conn.local_host).to be(nil)
+      end
+
+      it 'sets the local_host address' do
+        Puppet[:sourceaddress] = "127.0.0.1"
+        if RUBY_VERSION.to_i >= 2
+          conn = create_connection(site)
+
+          expect(conn.local_host).to eq('127.0.0.1')
+        else
+          expect {
+            create_connection(site)
+          }.to raise_error(ArgumentError, "Setting 'sourceaddress' is unsupported by this version of Net::HTTP.")
+        end
+      end
+    end
   end
 end

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

@@ -14,31 +14,37 @@ describe Puppet::Network::HTTP::WEBrick do
 
   let(:address) { '127.0.0.1' }
   let(:port) { 31337 }
-
-  let(:server) do
-    s = Puppet::Network::HTTP::WEBrick.new
-    s.stubs(:setup_logger).returns(Hash.new)
-    s.stubs(:setup_ssl).returns(Hash.new)
-    s
-  end
+  let(:server) { Puppet::Network::HTTP::WEBrick.new }
+  let(:localcacert) { make_absolute("/ca/crt") }
+  let(:ssl_server_ca_auth) { make_absolute("/ca/ssl_server_auth_file") }
+  let(:key) { stub 'key', :content => "mykey" }
+  let(:cert) { stub 'cert', :content => "mycert" }
+  let(:host) { stub 'host', :key => key, :certificate => cert, :name => "yay", :ssl_store => "mystore" }
 
   let(:mock_ssl_context) do
     stub('ssl_context', :ciphers= => nil)
   end
 
+  let(:socket) { mock('socket') }
   let(:mock_webrick) do
-    stub('webrick',
-         :[] => {},
-         :listeners => [],
-         :status => :Running,
-         :mount => nil,
-         :start => nil,
-         :shutdown => nil,
-         :ssl_context => mock_ssl_context)
+    server = stub('webrick',
+                  :[] => {},
+                  :listeners => [],
+                  :status => :Running,
+                  :mount => nil,
+                  :shutdown => nil,
+                  :ssl_context => mock_ssl_context)
+    server.stubs(:start).yields(socket)
+    IO.stubs(:select).with([socket], nil, nil, anything).returns(true)
+    socket.stubs(:accept)
+    server.stubs(:run).with(socket)
+    server
   end
 
   before :each do
     WEBrick::HTTPServer.stubs(:new).returns(mock_webrick)
+    Puppet::SSL::Certificate.indirection.stubs(:find).with('ca').returns cert
+    Puppet::SSL::Host.stubs(:localhost).returns host
   end
 
   describe "when turning on listening" do
@@ -88,6 +94,13 @@ describe Puppet::Network::HTTP::WEBrick do
       expect(server).to be_listening
     end
 
+    it "is passed a yet to be accepted socket" do
+      socket.expects(:accept)
+
+      server.listen(address, port)
+      server.unlisten
+    end
+
     describe "when the REST protocol is requested" do
       it "should register the REST handler at /" do
         # We don't care about the options here.
@@ -192,18 +205,6 @@ describe Puppet::Network::HTTP::WEBrick do
   end
 
   describe "when configuring ssl" do
-    let(:server) { Puppet::Network::HTTP::WEBrick.new }
-    let(:localcacert) { make_absolute("/ca/crt") }
-    let(:ssl_server_ca_auth) { make_absolute("/ca/ssl_server_auth_file") }
-    let(:key) { stub 'key', :content => "mykey" }
-    let(:cert) { stub 'cert', :content => "mycert" }
-    let(:host) { stub 'host', :key => key, :certificate => cert, :name => "yay", :ssl_store => "mystore" }
-
-    before :each do
-      Puppet::SSL::Certificate.indirection.stubs(:find).with('ca').returns cert
-      Puppet::SSL::Host.stubs(:localhost).returns host
-    end
-
     it "should use the key from the localhost SSL::Host instance" do
       Puppet::SSL::Host.expects(:localhost).returns host
       host.expects(:key).returns key
@@ -236,8 +237,8 @@ describe Puppet::Network::HTTP::WEBrick do
       expect(server.setup_ssl[:SSLCACertificateFile]).to eq(ssl_server_ca_auth)
     end
 
-    it "should start ssl immediately" do
-      expect(server.setup_ssl[:SSLStartImmediately]).to be_truthy
+    it "should not start ssl immediately" do
+      expect(server.setup_ssl[:SSLStartImmediately]).to eq(false)
     end
 
     it "should enable ssl" do

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

@@ -44,4 +44,30 @@ describe "the sprintf function" do
     expect(result).to(eql("<overlong:  027   0XBEEF (foo     )>"))
   end
 
+  it 'does not attempt to mutate its arguments' do
+    args = ['%d', 1].freeze
+    expect { @scope.function_sprintf(args) }.to_not raise_error
+  end
+
+  it 'support named arguments in a hash with string keys' do
+    result = @scope.function_sprintf(["%<foo>d : %<bar>f", {'foo' => 1, 'bar' => 2}])
+    expect(result).to eq("1 : 2.000000")
+  end
+
+  it 'raises a key error if a key is not present' do
+    expect do
+      @scope.function_sprintf(["%<foo>d : %<zanzibar>f", {'foo' => 1, 'bar' => 2}])
+    end.to raise_error(KeyError, /key<zanzibar> not found/)
+  end
+
+  it 'a hash with string keys that is output formats as strings' do
+    result = @scope.function_sprintf(["%s", {'foo' => 1, 'bar' => 2}])
+    expect(result).to eq("{\"foo\"=>1, \"bar\"=>2}")
+  end
+
+  it 'named arguments hash with non string keys are tolerated' do
+    result = @scope.function_sprintf(["%<foo>d : %<bar>f", {'foo' => 1, 'bar' => 2, 1 => 2, [1] => 2, false => true, {} => {}}])
+    expect(result).to eq("1 : 2.000000")
+  end
+
 end

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

@@ -24,7 +24,7 @@ describe 'the static loader' do
     let(:loader) { loader = Puppet::Pops::Loader::StaticLoader.new() }
 
     %w{
-      Auegas
+      Augeas
       Component
       Computer
       Cron

data/spec/unit/pops/types/type_calculator_spec.rb

@@ -116,6 +116,10 @@ describe 'The type calculator' do
     PUnitType::DEFAULT
   end
 
+  def iterable_t(t = nil)
+    TypeFactory.iterable(t)
+  end
+
   def types
     Types
   end
@@ -1573,6 +1577,13 @@ describe 'The type calculator' do
         t2 = parser.parse('Type[PositiveIntegerType]', scope)
         expect(calculator.assignable?(t2, t1)).to be_truthy
       end
+
+      it 'An alias for a Type that describes an Iterable instance is assignable to Iterable' do
+        t = type_alias_t('MyType', 'Enum[a,b]').resolve(parser, nil)
+
+        # True because String is iterable and an instance of Enum is a String
+        expect(calculator.assignable?(iterable_t, t)).to be_truthy
+      end
     end
   end
 
@@ -1863,6 +1874,11 @@ describe 'The type calculator' do
         expect(calculator.instance?(t, 15)).to be_truthy
       end
 
+      it 'should consider t an instance of Iterable when aliased type is Iterable' do
+        t = type_alias_t('Alias', 'Enum[a, b]').resolve(parser, nil)
+        expect(calculator.instance?(iterable_t, t)).to be_truthy
+      end
+
       it 'should consider x an instance of the aliased type that uses self recursion' do
         t = type_alias_t('Tree', 'Hash[String,Variant[String,Tree]]')
         loader = Object.new
@@ -2064,6 +2080,11 @@ describe 'The type calculator' do
         expect(calculator.iterable(calculator.type(t))).to eq(nil)
       end
     end
+
+    it 'should produce an iterable for a type alias of an Iterable type' do
+      t = PTypeAliasType.new('MyAlias', nil, PIntegerType.new(1, 10))
+      expect(calculator.iterable(t).respond_to?(:each)).to eq(true)
+    end
   end
 
   context 'when dealing with different types of inference' do

data/spec/unit/pops/types/type_mismatch_describer_spec.rb

@@ -168,6 +168,15 @@ describe 'the type mismatch describer' do
       /parameter 'arg' expects a match for Enum\['a', 'b'\], got Sensitive/))
   end
 
+  it "will report the parameter of Type[<type alias>] using the alias name" do
+    code = <<-CODE
+      type Custom = String[1]
+      Custom.each |$x| { notice($x) }
+    CODE
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /expects an Iterable value, got Type\[Custom\]/))
+  end
+
   context 'when reporting a mismatch between' do
     let(:parser) { TypeParser.singleton }
     let(:subject) { TypeMismatchDescriber.singleton }

data/spec/unit/provider/service/smf_spec.rb

@@ -18,8 +18,6 @@ describe provider_class, :if => Puppet.features.posix? do
 
     FileTest.stubs(:file?).with('/usr/sbin/svcadm').returns true
     FileTest.stubs(:executable?).with('/usr/sbin/svcadm').returns true
-    FileTest.stubs(:file?).with('/usr/sbin/svccfg').returns true
-    FileTest.stubs(:executable?).with('/usr/sbin/svccfg').returns true
     FileTest.stubs(:file?).with('/usr/bin/svcs').returns true
     FileTest.stubs(:executable?).with('/usr/bin/svcs').returns true
     Facter.stubs(:value).with(:operatingsystem).returns('Solaris')
@@ -76,9 +74,9 @@ describe provider_class, :if => Puppet.features.posix? do
       @provider.expects(:svcs).with('-H', '-o', 'state,nstate', "/system/myservice").returns("online\t-")
       @provider.status
     end
-    it "should return absent if svcs can't find the service" do
+    it "should return stopped if svcs can't find the service" do
       @provider.stubs(:svcs).raises(Puppet::ExecutionFailure.new("no svc found"))
-      expect(@provider.status).to eq(:absent)
+      expect(@provider.status).to eq(:stopped)
     end
     it "should return running if online in svcs output" do
       @provider.stubs(:svcs).returns("online\t-")