puppet 4.10.0 → 5.0.0

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

@@ -41,8 +41,8 @@ describe 'The type factory' do
       expect(TypeFactory.scalar().class()).to eq(PScalarType)
     end
 
-    it 'data() returns PDataType' do
-      expect(TypeFactory.data().class()).to eq(PDataType)
+    it 'data() returns Data' do
+      expect(TypeFactory.data.name).to eq('Data')
     end
 
     it 'optional() returns POptionalType' do
@@ -163,24 +163,24 @@ describe 'The type factory' do
       expect(at.element_type.class).to eq(PIntegerType)
     end
 
-    it 'array_of_data returns PArrayType[PDataType]' do
+    it 'array_of_data returns Array[Data]' do
       at = TypeFactory.array_of_data
       expect(at.class()).to eq(PArrayType)
-      expect(at.element_type.class).to eq(PDataType)
+      expect(at.element_type.name).to eq('Data')
     end
 
-    it 'hash_of_data returns PHashType[PScalarType,PDataType]' do
+    it 'hash_of_data returns Hash[String,Data]' do
       ht = TypeFactory.hash_of_data
       expect(ht.class()).to eq(PHashType)
-      expect(ht.key_type.class).to eq(PScalarType)
-      expect(ht.value_type.class).to eq(PDataType)
+      expect(ht.key_type.class).to eq(PStringType)
+      expect(ht.value_type.name).to eq('Data')
     end
 
-    it 'ruby(1) returns PRuntimeType[ruby, \'Fixnum\']' do
+    it 'ruby(1) returns PRuntimeType[ruby, \'Integer\']' do
       ht = TypeFactory.ruby(1)
       expect(ht.class()).to eq(PRuntimeType)
       expect(ht.runtime).to eq(:ruby)
-      expect(ht.runtime_type_name).to eq('Fixnum')
+      expect(ht.runtime_type_name).to eq(1.class.name)
     end
 
     it 'a size constrained collection can be created from array' do

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

@@ -38,9 +38,13 @@ describe 'The type formatter' do
       expect(s.indented_string({'a' => 32,'b' => [1, 2, {'c' => 'd'}]})).to eq(<<-FORMATTED)
 {
   'a' => 32,
-  'b' => [1, 2, {
-    'c' => 'd'
-  }]
+  'b' => [
+    1,
+    2,
+    {
+      'c' => 'd'
+    }
+  ]
 }
 FORMATTED
     end
@@ -49,9 +53,13 @@ FORMATTED
       expect(s.indented_string({'a' => 32,'b' => [1, 2, {'c' => 'd'}]}, 3)).to eq(<<-FORMATTED)
       {
         'a' => 32,
-        'b' => [1, 2, {
-          'c' => 'd'
-        }]
+        'b' => [
+          1,
+          2,
+          {
+            'c' => 'd'
+          }
+        ]
       }
 FORMATTED
     end
@@ -60,13 +68,17 @@ FORMATTED
       expect(s.indented_string({'a' => 32,'b' => [1, 2, {'c' => 'd'}]}, 2, 4)).to eq(<<-FORMATTED)
         {
             'a' => 32,
-            'b' => [1, 2, {
-                'c' => 'd'
-            }]
+            'b' => [
+                1,
+                2,
+                {
+                    'c' => 'd'
+                }
+            ]
         }
-    FORMATTED
+FORMATTED
+    end
   end
-end
 
   context 'when representing the type as string' do
     include_context 'types_setup'
@@ -87,7 +99,7 @@ end
       expect(s.string(f.boolean)).to eq('Boolean')
     end
 
-    it "should yield 'Data' for PDataType" do
+    it "should yield 'Data' for the Data type" do
       expect(s.string(f.data)).to eq('Data')
     end
 
@@ -138,8 +150,8 @@ end
       expect(s.string(f.array_of(f.integer))).to eq('Array[Integer]')
     end
 
-    it "should yield 'Array' for PArrayType::DATA" do
-      expect(s.string(f.array_of_data)).to eq('Array')
+    it "should yield 'Array' for PArrayType::DEFAULT" do
+      expect(s.string(f.array_of_any)).to eq('Array')
     end
 
     it "should yield 'Array[0, 0]' for an empty array" do
@@ -203,15 +215,16 @@ end
     end
 
     it "should yield 'Timestamp['2016-09-05T13:00:00.000 UTC'] for PTimestampType[Timestamp]" do
-      expect(s.string(f.timestamp('2016-09-05T13:00:00.000 UTC'))).to eq("Timestamp['2016-09-05T13:00:00.000 UTC']")
+      expect(s.string(f.timestamp('2016-09-05T13:00:00.000 UTC'))).to eq("Timestamp['2016-09-05T13:00:00.000000000 UTC']")
     end
 
     it "should yield 'Timestamp[default, '2016-09-05T13:00:00.000 UTC'] for PTimestampType[nil, Timestamp]" do
-      expect(s.string(f.timestamp(nil, '2016-09-05T13:00:00.000 UTC'))).to eq("Timestamp[default, '2016-09-05T13:00:00.000 UTC']")
+      expect(s.string(f.timestamp(nil, '2016-09-05T13:00:00.000 UTC'))).to eq("Timestamp[default, '2016-09-05T13:00:00.000000000 UTC']")
     end
 
     it "should yield 'Timestamp['2016-09-05T13:00:00.000 UTC', '2016-12-01T00:00:00.000 UTC'] for PTimestampType[Timestamp, Timestamp]" do
-      expect(s.string(f.timestamp('2016-09-05T13:00:00.000 UTC', '2016-12-01T00:00:00.000 UTC'))).to eq("Timestamp['2016-09-05T13:00:00.000 UTC', '2016-12-01T00:00:00.000 UTC']")
+      expect(s.string(f.timestamp('2016-09-05T13:00:00.000 UTC', '2016-12-01T00:00:00.000 UTC'))).to(
+        eq("Timestamp['2016-09-05T13:00:00.000000000 UTC', '2016-12-01T00:00:00.000000000 UTC']"))
     end
 
     it "should yield 'Tuple[Integer]' for PTupleType[PIntegerType]" do
@@ -248,8 +261,8 @@ end
       expect(s.string(f.hash_of(f.string, f.string, f.range(2, :default)))).to eq('Hash[String, String, 2, default]')
     end
 
-    it "should yield 'Hash' for PHashType::DATA" do
-      expect(s.string(f.hash_of_data)).to eq('Hash')
+    it "should yield 'Hash' for PHashType::DEFAULT" do
+      expect(s.string(f.hash_of_any)).to eq('Hash')
     end
 
     it "should yield 'Class' for a PHostClassType" do

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

@@ -54,12 +54,12 @@ describe TypeParser do
     expect(the_type_parsed_from(types.default)).to be_the_type(types.default)
   end
 
-  it "interprets an unparameterized Array as an Array of Data" do
-    expect(parser.parse("Array")).to be_the_type(types.array_of_data)
+  it "interprets an unparameterized Array as an Array of Any" do
+    expect(parser.parse("Array")).to be_the_type(types.array_of_any)
   end
 
-  it "interprets an unparameterized Hash as a Hash of Scalar to Data" do
-    expect(parser.parse("Hash")).to be_the_type(types.hash_of_data)
+  it "interprets an unparameterized Hash as a Hash of Any, Any" do
+    expect(parser.parse("Hash")).to be_the_type(types.hash_of_any)
   end
 
   it "interprets a parameterized Array[0, 0] as an empty hash with no key and value type" do
@@ -223,11 +223,11 @@ describe TypeParser do
 
   context 'without a scope' do
     it "interprets anything that is not a built in type to be a type reference" do
-      expect(parser.parse('File')).to eq(types.type_reference('File'))
+      expect(parser.parse('TestType')).to eq(types.type_reference('TestType'))
     end
 
     it "interprets anything that is not a built in type with parameterers to be type reference with parameters" do
-      expect(parser.parse("File['/tmp/foo']")).to eq(types.type_reference("File['/tmp/foo']"))
+      expect(parser.parse("TestType['/tmp/foo']")).to eq(types.type_reference("TestType['/tmp/foo']"))
     end
   end
 

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

@@ -352,13 +352,35 @@ describe 'Puppet Type System' do
     end
 
     it 'can be created with a runtime and, puppet name pattern, and runtime replacement' do
-      expect(tf.runtime('ruby', [/^MyPackage::(.*)$/, 'MyModule::\1']).to_s).to eq("Runtime[ruby, [/^MyPackage::(.*)$/, \"MyModule::\\\\1\"]]")
+      expect(tf.runtime('ruby', [/^MyPackage::(.*)$/, 'MyModule::\1']).to_s).to eq("Runtime[ruby, [/^MyPackage::(.*)$/, 'MyModule::\\1']]")
     end
 
     it 'will map a Puppet name to a runtime type' do
       t = tf.runtime('ruby', [/^MyPackage::(.*)$/, 'MyModule::\1'])
       expect(t.from_puppet_name('MyPackage::MyType').to_s).to eq("Runtime[ruby, 'MyModule::MyType']")
     end
+
+    it 'with parameters is assignable to the default Runtime type' do
+      code = <<-CODE
+      notice(Runtime[ruby, 'Symbol'] < Runtime)
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true'])
+    end
+
+    it 'with parameters is not assignable from the default Runtime type' do
+      code = <<-CODE
+      notice(Runtime < Runtime[ruby, 'Symbol'])
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['false'])
+    end
+
+    it 'default is assignable to itself' do
+      code = <<-CODE
+      notice(Runtime < Runtime)
+      notice(Runtime <= Runtime)
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['false', 'true'])
+    end
   end
 
   context 'Type aliases' do
@@ -439,7 +461,7 @@ describe 'Puppet Type System' do
       type Foo = Variant[Foo,String,Integer]
       assert_type(Foo, /x/)
       CODE
-      expect { eval_and_collect_notices(code) }.to raise_error(/expects a value of type String or Integer, got Regexp/)
+      expect { eval_and_collect_notices(code) }.to raise_error(/expects a Foo = Variant\[String, Integer\] value, got Regexp/)
     end
 
     it 'will handle a scalar correctly in combinations of nested aliased variants' do
@@ -558,6 +580,12 @@ describe 'Puppet Type System' do
       expect(func_class).to be_a(Class)
       expect(func_class.superclass).to be(Puppet::Functions::Function)
     end
+
+    it 'Regexp' do
+      func_class = tf.regexp.new_function(loader)
+      expect(func_class).to be_a(Class)
+      expect(func_class.superclass).to be(Puppet::Functions::Function)
+    end
   end
 
   context 'instantiation via new_function is not supported by' do
@@ -583,6 +611,11 @@ describe 'Puppet Type System' do
       expect(int).to eq(32)
     end
 
+    it 'is supported by Regexp' do
+      rx = tf.regexp.create('[a-z]+')
+      expect(rx).to eq(/[a-z]+/)
+    end
+
     it 'is supported by Optional[Integer]' do
       int = tf.optional(tf.integer).create('32')
       expect(int).to eq(32)
@@ -594,6 +627,24 @@ describe 'Puppet Type System' do
       end
     end
   end
+
+  context 'creation of parameterized type via ruby create function on class' do
+    around(:each) do |example|
+      Puppet.override(:loaders => Loaders.new(Puppet::Node::Environment.create(:testing, []))) do
+        example.run
+      end
+    end
+
+    it 'is supported by Integer' do
+      int_type = tf.integer.class.create(0, 32)
+      expect(int_type).to eq(tf.range(0, 32))
+    end
+
+    it 'is supported by Regexp' do
+      rx_type = tf.regexp.class.create('[a-z]+')
+      expect(rx_type).to eq(tf.regexp(/[a-z]+/))
+    end
+  end
 end
 end
 end

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

@@ -11,8 +11,8 @@ describe "validating 4x" do
   let(:acceptor) { Puppet::Pops::Validation::Acceptor.new() }
   let(:validator) { Puppet::Pops::Validation::ValidatorFactory_4_0.new().validator(acceptor) }
 
-  def validate(model)
-    validator.validate(model)
+  def validate(factory)
+    validator.validate(factory.model)
     acceptor
   end
 
@@ -56,20 +56,6 @@ describe "validating 4x" do
       expect(acceptor.error_count).to eql(0)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
     end
-
-    it 'produces a warning for duplicate default in a case expression' do
-      acceptor = validate(parse('case 1 { default: {1} default : {2} }'))
-      expect(acceptor.warning_count).to eql(1)
-      expect(acceptor.error_count).to eql(0)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
-    end
-
-    it 'produces a warning for duplicate default in a selector expression' do
-      acceptor = validate(parse(' 1 ? { default => 1, default => 2 }'))
-      expect(acceptor.warning_count).to eql(1)
-      expect(acceptor.error_count).to eql(0)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
-    end
   end
 
   context 'with --strict set to warning' do
@@ -81,18 +67,18 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
     end
 
-    it 'produces a warning for duplicate default in a case expression' do
-      acceptor = validate(parse('case 1 { default: {1} default : {2} }'))
+    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::DUPLICATE_DEFAULT)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
 
-    it 'produces a warning for duplicate default in a selector expression' do
-      acceptor = validate(parse(' 1 ? { default => 1, default => 2 }'))
+    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::DUPLICATE_DEFAULT)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
   end
 
@@ -105,18 +91,25 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
     end
 
-    it 'produces an error for duplicate default in a case expression' do
-      acceptor = validate(parse('case 1 { default: {1} default : {2} }'))
+    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::DUPLICATE_DEFAULT)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
 
-    it 'produces an error for duplicate default in a selector expression' do
-      acceptor = validate(parse(' 1 ? { default => 1, default => 2 }'))
+    it 'does not produce an error for regular class resource' do
+      acceptor = validate(parse('class { test: }'))
+      expect(acceptor.warning_count).to eql(0)
+      expect(acceptor.error_count).to eql(0)
+      expect(acceptor).not_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::DUPLICATE_DEFAULT)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
   end
 
@@ -128,19 +121,35 @@ describe "validating 4x" do
       expect(acceptor.error_count).to eql(0)
       expect(acceptor).to_not have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
     end
+  end
 
-    it 'does not produce an error for duplicate default in a case expression' do
+  context 'irrespective of --strict' do
+    it 'produces an error for duplicate default in a case expression' do
       acceptor = validate(parse('case 1 { default: {1} default : {2} }'))
       expect(acceptor.warning_count).to eql(0)
-      expect(acceptor.error_count).to eql(0)
-      expect(acceptor).to_not have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
+      expect(acceptor.error_count).to eql(1)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
     end
 
-    it 'does not produce an error for duplicate default in a selector expression' do
+    it 'produces an error for duplicate default in a selector expression' do
       acceptor = validate(parse(' 1 ? { default => 1, default => 2 }'))
       expect(acceptor.warning_count).to eql(0)
+      expect(acceptor.error_count).to eql(1)
+      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_not have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
+      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
 
@@ -269,30 +278,6 @@ describe "validating 4x" do
     end
   end
 
-  context 'for future reserved words' do
-    ['application', 'produces', 'consumes'].each do |word|
-      it "produces an issue for the word '#{word}'" do
-        source = "$a = #{word}"
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::FUTURE_RESERVED_WORD)
-      end
-
-      it 'produces a warning issue when used as a class name' do
-        source = "class #{word} {}"
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::FUTURE_RESERVED_WORD)
-      end
-
-      it 'produces no warning or error when used as a parameter name' do
-        source = "define foo($#{word}) { notice $#{word} }"
-        expect(validate(parse(source)).diagnostics.empty?).to eq(true)
-      end
-
-      it 'produces no warning or error when used as an attribute name' do
-        source = "foo { bar: #{word} => ok }"
-        expect(validate(parse(source)).diagnostics.empty?).to eq(true)
-      end
-    end
-  end
-
   context 'for reserved type names' do
     [# type/Type, is a reserved name but results in syntax error because it is a keyword in lower case form
     'any',
@@ -563,9 +548,6 @@ describe "validating 4x" do
   end
 
   context "capability annotations" do
-    before(:each) { Puppet[:app_management] = true }
-    after(:each) { Puppet[:app_management] = false }
-
     ['produces', 'consumes'].each do |word|
       it "rejects illegal resource types in #{word} clauses" do
         expect(validate(parse("foo produces Bar {}"))).to have_issue(Puppet::Pops::Issues::ILLEGAL_CLASSREF)
@@ -582,7 +564,17 @@ describe "validating 4x" do
     end
   end
 
+  context 'literal values' do
+    it 'rejects a literal integer outside of max signed 64 bit range' do
+      expect(validate(parse("0x8000000000000000"))).to have_issue(Puppet::Pops::Issues::NUMERIC_OVERFLOW)
+    end
+
+    it 'rejects a literal integer outside of min signed 64 bit range' do
+      expect(validate(parse("-0x8000000000000001"))).to have_issue(Puppet::Pops::Issues::NUMERIC_OVERFLOW)
+    end
+  end
+
   def parse(source)
-    Puppet::Pops::Parser::Parser.new().parse_string(source)
+    Puppet::Pops::Parser::Parser.new.parse_string(source)
   end
 end

data/spec/unit/pops/visitor_spec.rb

@@ -40,7 +40,7 @@ describe Puppet::Pops::Visitor do
 
     it "should select method for superclass" do
       duck_processor = DuckProcessor.new
-      expect(duck_processor.hi(42)).to eq("Howdy Fixnum")
+      expect(duck_processor.hi(42)).to match(/Howdy (?:Fixnum|Integer)/)
     end
 
     it "should select method for superclass" do

data/spec/unit/property/list_spec.rb

@@ -35,8 +35,8 @@ describe list_class do
       expect(@property.is_to_s(["foo","bar"])).to eq("foo,bar")
     end
 
-    it "should be able to correctly convert ':absent' to a string" do
-      expect(@property.is_to_s(:absent)).to eq("absent")
+    it "should be able to correctly convert ':absent' to a quoted string" do
+      expect(@property.is_to_s(:absent)).to eq("'absent'")
     end
 
     describe "when adding should to current" do

data/spec/unit/provider/augeas/augeas_spec.rb

@@ -367,7 +367,7 @@ describe provider_class do
       it "should return false for nil" do
         expect(@provider.is_numeric?(nil)).to eq(false)
       end
-      it "should return true for Fixnums" do
+      it "should return true for Integers" do
         expect(@provider.is_numeric?(9)).to eq(true)
       end
       it "should return true for numbers in Strings" 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