puppet 4.10.1-universal-darwin → 4.10.4-universal-darwin

data/spec/unit/pops/lookup/interpolation_spec.rb

@@ -6,28 +6,57 @@ module Puppet::Pops
 describe 'Puppet::Pops::Lookup::Interpolation' do
   include Lookup::SubLookup
 
+  class InterpolationTestAdapter < Lookup::LookupAdapter
+    include Lookup::SubLookup
+
+    def initialize(data, interpolator)
+      @data = data
+      @interpolator = interpolator
+    end
+
+    def track(name)
+    end
+
+    def lookup(name, lookup_invocation, merge)
+      track(name)
+      segments = split_key(name)
+      root_key = segments.shift
+      found = @data[root_key]
+      found = sub_lookup(name, lookup_invocation, segments, found) unless segments.empty?
+      @interpolator.interpolate(found, lookup_invocation, true)
+    end
+  end
+
   let(:interpolator) { Class.new { include Lookup::Interpolation }.new }
   let(:scope) { {} }
+  let(:data) { {} }
+  let(:adapter) { InterpolationTestAdapter.new(data, interpolator) }
   let(:lookup_invocation) { Lookup::Invocation.new(scope, {}, {}, nil) }
 
+  before(:each) do
+    Lookup::Invocation.any_instance.stubs(:lookup_adapter).returns(adapter)
+  end
+
   def expect_lookup(*keys)
-    keys.each do |key|
-      segments = split_key(key)
-      root_key = segments.shift
-      found = data[root_key]
-      found = sub_lookup(key, lookup_invocation, segments, found) unless segments.empty?
-      Lookup.expects(:lookup).with(key, nil, '', true, nil, is_a(Lookup::Invocation)).returns(found)
-    end
+    keys.each { |key| adapter.expects(:track).with(key) }
   end
 
   context 'when interpolating nested data' do
     let(:nested_hash) { {'a' => {'aa' => "%{alias('aaa')}"}} }
 
+    let(:scope) {
+      {
+        'ds1' => 'a',
+        'ds2' => 'b'
+      }
+    }
+
     let(:data) {
       {
         'aaa' => {'b' => {'bb' => "%{alias('bbb')}"}},
         'bbb' => ["%{alias('ccc')}"],
-        'ccc' => 'text'
+        'ccc' => 'text',
+        'ddd' => "%{literal('%')}{ds1}_%{literal('%')}{ds2}",
       }
     }
 
@@ -35,6 +64,16 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
       expect_lookup('aaa', 'bbb', 'ccc')
       expect(interpolator.interpolate(nested_hash, lookup_invocation, true)).to eq('a' => {'aa' => {'b' => {'bb' => ['text']}}})
     end
+
+    it "'%{lookup('key')} will interpolate the returned value'" do
+      expect_lookup('ddd')
+      expect(interpolator.interpolate("%{lookup('ddd')}", lookup_invocation, true)).to eq('a_b')
+    end
+
+    it "'%{alias('key')} will not interpolate the returned value'" do
+      expect_lookup('ddd')
+      expect(interpolator.interpolate("%{alias('ddd')}", lookup_invocation, true)).to eq('%{ds1}_%{ds2}')
+    end
   end
 
   context 'when interpolating boolean scope values' do
@@ -242,7 +281,8 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
     end
 
     it 'should not find a subkey that is matched within a string' do
-      expect{ expect_lookup('key.subkey') }.to raise_error(/Got String when a hash-like object was expected to access value using 'subkey' from key 'key.subkey'/)
+      expect{ interpolator.interpolate("%{lookup('key.subkey')}", lookup_invocation, true) }.to raise_error(
+        /Got String when a hash-like object was expected to access value using 'subkey' from key 'key.subkey'/)
     end
   end
 

data/spec/unit/pops/lookup/lookup_spec.rb

@@ -57,6 +57,13 @@ describe 'The lookup API' do
           mod::c: mod::c (from module)
           mod::e: mod::e (from module)
           mod::f: mod::f (from module)
+          mod::g:
+            :symbol: symbol key value
+            key: string key value
+            6: integer key value
+            -4: negative integer key value
+            2.7: float key value
+            '6': string integer key value
           YAML
       }
     }
@@ -137,6 +144,31 @@ describe 'The lookup API' do
       expect(Lookup.lookup('mod::f', nil, 'not found', true, nil, invocation)).to eql('mod::f (from environment)')
     end
 
+    it 'returns the correct types for hash keys' do
+      expect(Lookup.lookup('mod::g', nil, 'not found', true, nil, invocation)).to eql(
+	      {
+          'symbol' => 'symbol key value',
+		      'key' => 'string key value',
+		      6 => 'integer key value',
+          -4 => 'negative integer key value',
+		      2.7 => 'float key value',
+          '6' => 'string integer key value'
+	      }
+      )
+    end
+
+    it 'can navigate a hash with an integer key using a dotted key' do
+      expect(Lookup.lookup('mod::g.6', nil, 'not found', true, nil, invocation)).to eql('integer key value')
+    end
+
+    it 'can navigate a hash with a negative integer key using a dotted key' do
+      expect(Lookup.lookup('mod::g.-4', nil, 'not found', true, nil, invocation)).to eql('negative integer key value')
+    end
+
+    it 'can navigate a hash with an string integer key using a dotted key with quoted integer' do
+      expect(Lookup.lookup("mod::g.'6'", nil, 'not found', true, nil, invocation)).to eql('string integer key value')
+    end
+
     context "with 'global_only' set to true in the invocation" do
       let(:invocation) { Invocation.new(scope).set_global_only }
 

data/spec/unit/pops/parser/lexer2_spec.rb

@@ -412,6 +412,34 @@ describe 'Lexer2' do
     expect(tokens_scanned_from("1 / /./")).to match_tokens2(:NUMBER, :DIV, :REGEX)
   end
 
+  it 'should lex regexp with escaped slash' do
+    scanned = tokens_scanned_from('/\//')
+    expect(scanned).to match_tokens2(:REGEX)
+    expect(scanned[0][1][:value]).to eql(Regexp.new('/'))
+  end
+
+  it 'should lex regexp with escaped backslash' do
+    scanned = tokens_scanned_from('/\\\\/')
+    expect(scanned).to match_tokens2(:REGEX)
+    expect(scanned[0][1][:value]).to eql(Regexp.new('\\\\'))
+  end
+
+  it 'should lex regexp with escaped backslash followed escaped slash ' do
+    scanned = tokens_scanned_from('/\\\\\\//')
+    expect(scanned).to match_tokens2(:REGEX)
+    expect(scanned[0][1][:value]).to eql(Regexp.new('\\\\/'))
+  end
+
+  it 'should lex regexp with escaped slash followed escaped backslash ' do
+    scanned = tokens_scanned_from('/\\/\\\\/')
+    expect(scanned).to match_tokens2(:REGEX)
+    expect(scanned[0][1][:value]).to eql(Regexp.new('/\\\\'))
+  end
+
+  it 'should not lex regexp with escaped ending slash' do
+    expect(tokens_scanned_from('/\\/')).to match_tokens2(:DIV, :OTHER, :DIV)
+  end
+
   it "should accept newline in a regular expression" do
     scanned = tokens_scanned_from("/\n.\n/")
     # Note that strange formatting here is important

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

@@ -20,7 +20,7 @@ describe 'The Object Type' do
 
   def type_object_t(name, body_string)
     object = PObjectType.new(name, pp_parser.parse_string("{#{body_string}}").current.body)
-    loader.set_entry(Loader::TypedName.new(:type, name.downcase), object)
+    loader.set_entry(Loader::TypedName.new(:type, name), object)
     object
   end
 

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

@@ -16,7 +16,7 @@ module Puppet::Pops
       def type_set_t(name, body_string, name_authority)
         i12n_literal_hash = pp_parser.parse_string("{#{body_string}}").current.body
         typeset = PTypeSetType.new(name, i12n_literal_hash, name_authority)
-        loader.set_entry(Loader::TypedName.new(:type, name.downcase, name_authority), typeset)
+        loader.set_entry(Loader::TypedName.new(:type, name, name_authority), typeset)
         typeset
       end
 

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

@@ -874,6 +874,22 @@ describe 'The string converter' do
     end
   end
 
+  context 'when converting a runtime type' do
+    [ :sym, (1..3), Time.now ].each do |value|
+      it "the default string representation for #{value} is #to_s" do
+        expect(converter.convert(value, :default)).to eq(value.to_s)
+      end
+
+      it "the '%q' string representation for #{value} is #inspect" do
+        expect(converter.convert(value, '%q')).to eq(value.inspect)
+      end
+    end
+
+    it 'an unknown format raises an error' do
+      expect { converter.convert(:sym, '%b') }.to raise_error("Illegal format 'b' specified for value of Runtime type - expected one of the characters 'sq'")
+    end
+  end
+
   context 'when converting regexp' do
     it 'the default string representation is "regexp"' do
       expect(converter.convert(/.*/, :default)).to eq('.*')
@@ -906,6 +922,11 @@ describe 'The string converter' do
         string_formats = { Puppet::Pops::Types::PRegexpType::DEFAULT => '%p'}
         expect(converter.convert(/[a-z]\s*/m, string_formats)).to eq('/(?m-ix:[a-z]\s*)/')
       end
+
+      it 'the format %p produces \'/foo\/bar/\' for expression /foo\/bar/' do
+        string_formats = { Puppet::Pops::Types::PRegexpType::DEFAULT => '%p'}
+        expect(converter.convert(/foo\/bar/, string_formats)).to eq('/foo\/bar/')
+      end
     end
 
     it 'errors when format is not recognized' do

data/spec/unit/pops/validator/validator_spec.rb

@@ -94,6 +94,21 @@ describe "validating 4x" do
       expect(acceptor.error_count).to eql(0)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
     end
+
+    it 'produces a warning for virtual class resource' do
+      acceptor = validate(parse('@class { test: }'))
+      expect(acceptor.warning_count).to eql(1)
+      expect(acceptor.error_count).to eql(0)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
+    end
+
+    it 'produces a  warning for exported class resource' do
+      acceptor = validate(parse('@@class { test: }'))
+      expect(acceptor.warning_count).to eql(1)
+      expect(acceptor.error_count).to eql(0)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
+    end
+
   end
 
   context 'with --strict set to error' do
@@ -118,6 +133,20 @@ describe "validating 4x" do
       expect(acceptor.error_count).to eql(1)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
     end
+
+    it 'produces an error for virtual class resource' do
+      acceptor = validate(parse('@class { test: }'))
+      expect(acceptor.warning_count).to eql(0)
+      expect(acceptor.error_count).to eql(1)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
+    end
+
+    it 'produces an error for exported class resource' do
+      acceptor = validate(parse('@@class { test: }'))
+      expect(acceptor.warning_count).to eql(0)
+      expect(acceptor.error_count).to eql(1)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
+    end
   end
 
   context 'with --strict set to off' do
@@ -142,6 +171,20 @@ describe "validating 4x" do
       expect(acceptor.error_count).to eql(0)
       expect(acceptor).to_not have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
     end
+
+    it 'produces a warning for virtual class resource' do
+      acceptor = validate(parse('@class { test: }'))
+      expect(acceptor.warning_count).to eql(1)
+      expect(acceptor.error_count).to eql(0)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
+    end
+
+    it 'produces a  warning for exported class resource' do
+      acceptor = validate(parse('@@class { test: }'))
+      expect(acceptor.warning_count).to eql(1)
+      expect(acceptor.error_count).to eql(0)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
+    end
   end
 
   context 'for non productive expressions' do

data/spec/unit/provider/nameservice/directoryservice_spec.rb

@@ -11,6 +11,7 @@ end
   describe provider_class do
     before do
       @resource = stub("resource")
+      @resource.stubs(:[]).with(:name)
       @provider = provider_class.new(@resource)
     end
 
@@ -143,6 +144,7 @@ describe '(#4855) directoryservice group resource failure' do
 
   before :each do
     @resource = stub("resource")
+    @resource.stubs(:[]).with(:name)
     @provider = provider_class.new(@resource)
   end
 

data/spec/unit/provider/nameservice_spec.rb

@@ -3,6 +3,7 @@
 require 'spec_helper'
 require 'puppet/provider/nameservice'
 require 'puppet/etc'
+require 'puppet_spec/character_encoding'
 
 describe Puppet::Provider::NameService do
 
@@ -60,6 +61,36 @@ describe Puppet::Provider::NameService do
     resource
   end
 
+  # These values simulate what Ruby Etc would return from a host with the "same"
+  # user represented in different encodings on disk.
+  let(:utf_8_jose) { "Jos\u00E9"}
+  let(:utf_8_labeled_as_latin_1_jose) { utf_8_jose.dup.force_encoding(Encoding::ISO_8859_1) }
+  let(:valid_latin1_jose) { utf_8_jose.encode(Encoding::ISO_8859_1)}
+  let(:invalid_utf_8_jose) { valid_latin1_jose.dup.force_encoding(Encoding::UTF_8) }
+  let(:escaped_utf_8_jose) { "Jos\uFFFD".force_encoding(Encoding::UTF_8) }
+
+  let(:utf_8_mixed_users) {
+    [
+      Struct::Passwd.new('root', 'x', 0, 0),
+      Struct::Passwd.new('foo', 'x', 1000, 2000),
+      Struct::Passwd.new(utf_8_jose, utf_8_jose, 1001, 2000), # UTF-8 character
+      # In a UTF-8 environment, ruby will return strings labeled as UTF-8 even if they're not valid in UTF-8
+      Struct::Passwd.new(invalid_utf_8_jose, invalid_utf_8_jose, 1002, 2000),
+      nil
+    ]
+  }
+
+  let(:latin_1_mixed_users) {
+    [
+      # In a LATIN-1 environment, ruby will return *all* strings labeled as LATIN-1
+      Struct::Passwd.new('root'.force_encoding(Encoding::ISO_8859_1), 'x', 0, 0),
+      Struct::Passwd.new('foo'.force_encoding(Encoding::ISO_8859_1), 'x', 1000, 2000),
+      Struct::Passwd.new(utf_8_labeled_as_latin_1_jose, utf_8_labeled_as_latin_1_jose, 1002, 2000),
+      Struct::Passwd.new(valid_latin1_jose, valid_latin1_jose, 1001, 2000), # UTF-8 character
+      nil
+    ]
+  }
+
   describe "#options" do
     it "should add options for a valid property" do
       described_class.options :foo, :key1 => 'val1', :key2 => 'val2'
@@ -121,6 +152,11 @@ describe Puppet::Provider::NameService do
   end
 
   describe "#listbyname" do
+    it "should be deprecated" do
+      Puppet.expects(:deprecation_warning).with(regexp_matches(/listbyname is deprecated/))
+      described_class.listbyname
+    end
+
     it "should return a list of users if resource_type is user" do
       described_class.resource_type = Puppet::Type.type(:user)
       Puppet::Etc.expects(:setpwent)
@@ -129,6 +165,30 @@ describe Puppet::Provider::NameService do
       expect(described_class.listbyname).to eq(%w{root foo})
     end
 
+    context "encoding handling" do
+      described_class.resource_type = Puppet::Type.type(:user)
+
+      # These two tests simulate an environment where there are two users with
+      # the same name on disk, but each name is stored on disk in a different
+      # encoding
+      it "should return names with invalid byte sequences replaced with '?'" do
+        Etc.stubs(:getpwent).returns *utf_8_mixed_users
+        expect(invalid_utf_8_jose).to_not be_valid_encoding
+        result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::UTF_8) do
+          described_class.listbyname
+        end
+        expect(result).to eq(['root', 'foo', utf_8_jose, escaped_utf_8_jose])
+      end
+
+      it "should return names in their original encoding/bytes if they would not be valid UTF-8" do
+        Etc.stubs(:getpwent).returns *latin_1_mixed_users
+        result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::ISO_8859_1) do
+          described_class.listbyname
+        end
+        expect(result).to eq(['root'.force_encoding(Encoding::UTF_8), 'foo'.force_encoding(Encoding::UTF_8), utf_8_jose, valid_latin1_jose])
+      end
+    end
+
     it "should return a list of groups if resource_type is group", :unless => Puppet.features.microsoft_windows? do
       described_class.resource_type = Puppet::Type.type(:group)
       Puppet::Etc.expects(:setgrent)
@@ -149,9 +209,44 @@ describe Puppet::Provider::NameService do
   end
 
   describe "instances" do
-    it "should return a list of objects based on listbyname" do
-      described_class.expects(:listbyname).multiple_yields 'root', 'foo', 'nobody'
-      expect(described_class.instances.map(&:name)).to eq(%w{root foo nobody})
+    it "should return a list of objects in UTF-8 with any invalid characters replaced with '?'" do
+      # These two tests simulate an environment where there are two users with
+      # the same name on disk, but each name is stored on disk in a different
+      # encoding
+      Etc.stubs(:getpwent).returns(*utf_8_mixed_users)
+      result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::UTF_8) do
+        described_class.instances
+      end
+      expect(result.map(&:name)).to eq(
+        [
+          'root'.force_encoding(Encoding::UTF_8), # started as UTF-8 on disk, returned unaltered as UTF-8
+          'foo'.force_encoding(Encoding::UTF_8), # started as UTF-8 on disk, returned unaltered as UTF-8
+          utf_8_jose, # started as UTF-8 on disk, returned unaltered as UTF-8
+          escaped_utf_8_jose # started as LATIN-1 on disk, but Etc returned as UTF-8 and we escaped invalid chars
+        ]
+      )
+    end
+
+    it "should have object names in their original encoding/bytes if they would not be valid UTF-8" do
+      Etc.stubs(:getpwent).returns(*latin_1_mixed_users)
+      result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::ISO_8859_1) do
+        described_class.instances
+      end
+      expect(result.map(&:name)).to eq(
+        [
+          'root'.force_encoding(Encoding::UTF_8), # started as LATIN-1 on disk, we overrode to UTF-8
+          'foo'.force_encoding(Encoding::UTF_8), # started as LATIN-1 on disk, we overrode to UTF-8
+          utf_8_jose, # started as UTF-8 on disk, returned by Etc as LATIN-1, and we overrode to UTF-8
+          valid_latin1_jose # started as LATIN-1 on disk, returned by Etc as valid LATIN-1, and we leave as LATIN-1
+        ]
+      )
+    end
+
+    it "should pass the Puppet::Etc :canonical_name Struct member to the constructor" do
+      users = [ Struct::Passwd.new(invalid_utf_8_jose, invalid_utf_8_jose, 1002, 2000), nil ]
+      Etc.stubs(:getpwent).returns(*users)
+      described_class.expects(:new).with(:name => escaped_utf_8_jose, :canonical_name => invalid_utf_8_jose, :ensure => :present)
+      described_class.instances
     end
   end
 
@@ -198,6 +293,21 @@ describe Puppet::Provider::NameService do
       provider.expects(:info2hash).never
       expect(provider.getinfo(true)).to be_nil
     end
+
+    # Nameservice instances track the original resource name on disk, before
+    # overriding to UTF-8, in @canonical_name for querying that state on disk
+    # again if needed
+    it "should use the instance's @canonical_name to query the system" do
+      provider_instance = described_class.new(:name => 'foo', :canonical_name => 'original_foo', :ensure => :present)
+      Puppet::Etc.expects(:send).with(:getfoonam, 'original_foo')
+      provider_instance.getinfo(true)
+    end
+
+    it "should use the instance's name instead of canonical_name if not supplied during instantiation" do
+      provider_instance = described_class.new(:name => 'foo', :ensure => :present)
+      Puppet::Etc.expects(:send).with(:getfoonam, 'foo')
+      provider_instance.getinfo(true)
+    end
   end
 
   describe "info2hash" do