puppet 4.8.2-universal-darwin → 4.9.0-universal-darwin

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

@@ -123,7 +123,7 @@ module Puppet::Pops
             version => '1.x',
             pcore_version => '1.0.0',
             OBJECT
-            expect { parse_type_set('MySet', ts) }.to raise_error(Semantic::Version::ValidationFailure)
+            expect { parse_type_set('MySet', ts) }.to raise_error(SemanticPuppet::Version::ValidationFailure)
           end
 
           it 'the pcore_version is an invalid semantic version' do
@@ -131,7 +131,7 @@ module Puppet::Pops
             version => '1.0.0',
             pcore_version => '1.x',
             OBJECT
-            expect { parse_type_set('MySet', ts) }.to raise_error(Semantic::Version::ValidationFailure)
+            expect { parse_type_set('MySet', ts) }.to raise_error(SemanticPuppet::Version::ValidationFailure)
           end
 
           it 'the pcore_version is outside of the range of that is parsable by this runtime' do
@@ -419,6 +419,35 @@ module Puppet::Pops
           OBJECT
         end
       end
+
+      it '#name_for method reports the name of deeply nested type correctly' do
+        tv = parse_type_set('Vehicles', <<-OBJECT)
+            version => '1.0.0',
+            pcore_version => '1.0.0',
+            types => { Car => Object[{}] }
+        OBJECT
+        tt = parse_type_set('Transports', <<-OBJECT)
+            version => '1.0.0',
+            pcore_version => '1.0.0',
+            references => {
+              Vecs => {
+                name => 'Vehicles',
+                version_range => '1.x'
+              }
+            }
+        OBJECT
+        ts = parse_type_set('TheSet', <<-OBJECT)
+            version => '1.0.0',
+            pcore_version => '1.0.0',
+            references => {
+              T => {
+                name => 'Transports',
+                version_range => '1.x'
+              }
+            }
+        OBJECT
+        expect(ts.name_for(tv['Car'], nil)).to eql('T::Vecs::Car')
+      end
     end
   end
 end

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

@@ -1,24 +1,25 @@
 require 'spec_helper'
 require 'puppet/pops/types/type_acceptor'
 
+class PuppetSpec::TestTypeAcceptor
+  include Puppet::Pops::Types::TypeAcceptor
+  attr_reader :visitors, :guard
+
+  def initialize
+    @visitors = []
+    @guard = nil
+  end
+
+  def visit(type, guard)
+    @visitors << type
+    @guard = guard
+  end
+end
+
 module Puppet::Pops::Types
 describe 'the Puppet::Pops::Types::TypeAcceptor' do
-  let!(:acceptor_class) do
-    Class.new do
-      include TypeAcceptor
-      attr_reader :visitors, :guard
-
-      def initialize
-        @visitors = []
-        @guard = nil
-      end
-
-      def visit(type, guard)
-        @visitors << type
-        @guard = guard
-      end
-    end
-  end
+
+  let!(:acceptor_class) { PuppetSpec::TestTypeAcceptor }
 
   let(:acceptor) { acceptor_class.new }
   let(:guard) { RecursionGuard.new }
@@ -102,4 +103,4 @@ describe 'the Puppet::Pops::Types::TypeAcceptor' do
     expect(acceptor.visitors).to include(t, PStringType::DEFAULT, PIntegerType::DEFAULT)
   end
 end
-end
+end

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

@@ -18,12 +18,12 @@ describe 'The type calculator' do
     TypeFactory.regexp(pattern)
   end
 
-  def string_t(*strings)
-    TypeFactory.string(nil, *strings)
+  def string_t(string = nil)
+    TypeFactory.string(string)
   end
 
-  def constrained_string_t(size_type, *strings)
-    TypeFactory.string(size_type, *strings)
+  def constrained_string_t(size_type)
+    TypeFactory.string(size_type)
   end
 
   def callable_t(*params)
@@ -141,7 +141,7 @@ describe 'The type calculator' do
     it 'inferred string type knows the string value' do
       t = calculator.infer('foo')
       expect(t.class).to eq(PStringType)
-      expect(t.values).to eq(['foo'])
+      expect(t.value).to eq('foo')
     end
 
     it 'boolean true translates to PBooleanType' do
@@ -222,15 +222,15 @@ describe 'The type calculator' do
 
     context 'version' do
       it 'translates to PVersionType' do
-        expect(calculator.infer(Semantic::Version.new(1,0,0)).class).to eq(PSemVerType)
+        expect(calculator.infer(SemanticPuppet::Version.new(1,0,0)).class).to eq(PSemVerType)
       end
 
       it 'range translates to PVersionRangeType' do
-        expect(calculator.infer(Semantic::VersionRange.parse('1.x')).class).to eq(PSemVerRangeType)
+        expect(calculator.infer(SemanticPuppet::VersionRange.parse('1.x')).class).to eq(PSemVerRangeType)
       end
 
       it 'translates to a limited PVersionType by infer_set' do
-        v = Semantic::Version.new(1,0,0)
+        v = SemanticPuppet::Version.new(1,0,0)
         t = calculator.infer_set(v)
         expect(t.class).to eq(PSemVerType)
         expect(t.ranges.size).to eq(1)
@@ -287,9 +287,9 @@ describe 'The type calculator' do
         expect(t.to).to eq(42)
       end
 
-      it 'Compound string values are computed' do
+      it 'Compound string values are converted to enums' do
         t = calculator.infer(['a','b', 'c']).element_type
-        expect(t.class).to eq(PStringType)
+        expect(t.class).to eq(PEnumType)
         expect(t.values).to eq(['a', 'b', 'c'])
       end
 
@@ -326,16 +326,16 @@ describe 'The type calculator' do
       end
 
       it 'with arrays of string values translates to PArrayType[PArrayType[PStringType]]' do
-        et = calculator.infer([['first' 'array'], ['second','array']])
+        et = calculator.infer([['first', 'array'], ['second','array']])
         expect(et.class).to eq(PArrayType)
         et = et.element_type
         expect(et.class).to eq(PArrayType)
         et = et.element_type
-        expect(et.class).to eq(PStringType)
+        expect(et.class).to eq(PEnumType)
       end
 
       it 'with array of string values and array of fixnums translates to PArrayType[PArrayType[PScalarType]]' do
-        et = calculator.infer([['first' 'array'], [1,2]])
+        et = calculator.infer([['first', 'array'], [1,2]])
         expect(et.class).to eq(PArrayType)
         et = et.element_type
         expect(et.class).to eq(PArrayType)
@@ -343,13 +343,13 @@ describe 'The type calculator' do
         expect(et.class).to eq(PScalarType)
       end
 
-      it 'with hashes of string values translates to PArrayType[PHashType[PStringType]]' do
+      it 'with hashes of string values translates to PArrayType[PHashType[PEnumType]]' do
         et = calculator.infer([{:first => 'first', :second => 'second' }, {:first => 'first', :second => 'second' }])
         expect(et.class).to eq(PArrayType)
         et = et.element_type
         expect(et.class).to eq(PHashType)
-        et = et.element_type
-        expect(et.class).to eq(PStringType)
+        et = et.value_type
+        expect(et.class).to eq(PEnumType)
       end
 
       it 'with hash of string values and hash of fixnums translates to PArrayType[PHashType[PScalarType]]' do
@@ -357,7 +357,7 @@ describe 'The type calculator' do
         expect(et.class).to eq(PArrayType)
         et = et.element_type
         expect(et.class).to eq(PHashType)
-        et = et.element_type
+        et = et.value_type
         expect(et.class).to eq(PScalarType)
       end
     end
@@ -374,12 +374,12 @@ describe 'The type calculator' do
         expect(k.runtime_type_name).to eq('Symbol')
       end
 
-      it 'with string keys translates to PHashType[PStringType, value]' do
-        expect(calculator.infer({'first' => 1, 'second' => 2}).key_type.class).to eq(PStringType)
+      it 'with string keys translates to PHashType[PEnumType, value]' do
+        expect(calculator.infer({'first' => 1, 'second' => 2}).key_type.class).to eq(PEnumType)
       end
 
       it 'with fixnum values translates to PHashType[key, PIntegerType]' do
-        expect(calculator.infer({:first => 1, :second => 2}).element_type.class).to eq(PIntegerType)
+        expect(calculator.infer({:first => 1, :second => 2}).value_type.class).to eq(PIntegerType)
       end
 
       it 'when empty infers a type that answers true to is_the_empty_hash?' do
@@ -435,8 +435,8 @@ describe 'The type calculator' do
       expect(t.patterns[0].regexp.match('abc')[1]).to eq('b')
     end
 
-    it 'constructs a PStringType with multiple strings' do
-      t = string_t('a', 'b', 'c', 'abc')
+    it 'constructs a PEnumType with multiple strings' do
+      t = enum_t('a', 'b', 'c', 'abc')
       expect(t.values).to eq(['a', 'b', 'c', 'abc'].sort)
     end
   end
@@ -482,7 +482,7 @@ describe 'The type calculator' do
         t1 = string_t('abc')
         t2 = string_t('xyz')
         common_t = calculator.common_type(t1,t2)
-        expect(common_t.class).to eq(PStringType)
+        expect(common_t.class).to eq(PEnumType)
         expect(common_t.values).to eq(['abc', 'xyz'])
       end
 
@@ -503,11 +503,11 @@ describe 'The type calculator' do
       end
 
       it 'computes values to be empty if the one has empty values' do
-        t1 = constrained_string_t(range_t(3,6), 'apa')
+        t1 = string_t('apa')
         t2 = constrained_string_t(range_t(2,4))
         common_t = calculator.common_type(t1,t2)
         expect(common_t.class).to eq(PStringType)
-        expect(common_t.values).to be_empty
+        expect(common_t.value).to be_nil
       end
     end
 
@@ -1154,7 +1154,7 @@ describe 'The type calculator' do
 
       it 'should accept multiple strings if they all match any patterns' do
         p_t = pattern_t('X', 'Y', 'abc')
-        p_s = string_t('Xa', 'aY', 'abc')
+        p_s = enum_t('Xa', 'aY', 'abc')
         expect(calculator.assignable?(p_t, p_s)).to eq(true)
       end
 
@@ -1166,7 +1166,7 @@ describe 'The type calculator' do
 
       it 'should reject multiple strings if not all match any patterns' do
         p_t = pattern_t('abc', 'ab', 'c', 'q')
-        p_s = string_t('X', 'Y', 'Z')
+        p_s = enum_t('X', 'Y', 'Z')
         expect(calculator.assignable?(p_t, p_s)).to eq(false)
       end
 
@@ -1661,9 +1661,8 @@ describe 'The type calculator' do
     end
 
     it 'should consider string values' do
-      string = string_t('a', 'b')
+      string = string_t('a')
       expect(calculator.instance?(string, 'a')).to eq(true)
-      expect(calculator.instance?(string, 'b')).to eq(true)
       expect(calculator.instance?(string, 'c')).to eq(false)
     end
 
@@ -1936,7 +1935,7 @@ describe 'The type calculator' do
       t = calculator.type(Hash)
       expect(t.class).to eq(PHashType)
       expect(t.key_type.class).to eq(PScalarType)
-      expect(t.element_type.class).to eq(PDataType)
+      expect(t.value_type.class).to eq(PDataType)
     end
   end
 
@@ -2066,25 +2065,25 @@ describe 'The type calculator' do
     end
 
     it 'a generic inference is produced using infer_generic' do
-      expect(calculator.infer_generic(['a','b']).element_type.values).to eq([])
+      expect(calculator.infer_generic(['a','b']).element_type).to eql(string_t(range_t(1,1)))
     end
 
     it 'a generic result is created by generalize given an instance specific result for an Array' do
       generic = calculator.infer(['a','b'])
-      expect(generic.element_type.values).to eq(['a', 'b'])
+      expect(generic.element_type.values).to eq(['a','b'])
       generic = generic.generalize
-      expect(generic.element_type.values).to eq([])
+      expect(generic.element_type).to eql(string_t(range_t(1,1)))
     end
 
     it 'a generic result is created by generalize given an instance specific result for a Hash' do
-      generic = calculator.infer({'a' =>1,'b' => 2})
-      expect(generic.key_type.values.sort).to eq(['a', 'b'])
-      expect(generic.element_type.from).to eq(1)
-      expect(generic.element_type.to).to eq(2)
+      generic = calculator.infer({'a' =>1,'bcd' => 2})
+      expect(generic.key_type.values.sort).to eq(['a', 'bcd'])
+      expect(generic.value_type.from).to eq(1)
+      expect(generic.value_type.to).to eq(2)
       generic = generic.generalize
-      expect(generic.key_type.values).to eq([])
-      expect(generic.element_type.from).to eq(nil)
-      expect(generic.element_type.to).to eq(nil)
+      expect(generic.key_type.size_type).to eq(range_t(1,3))
+      expect(generic.value_type.from).to eq(nil)
+      expect(generic.value_type.to).to eq(nil)
     end
 
     it 'ensures that Struct key types are not generalized' do

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

@@ -82,7 +82,7 @@ describe 'The type factory' do
     end
 
     it 'sem_ver(r1, r2) returns constrained PSemVerType' do
-      expect(TypeFactory.sem_ver('1.x', '3.x').ranges).to include(Semantic::VersionRange.parse('1.x'), Semantic::VersionRange.parse('3.x'))
+      expect(TypeFactory.sem_ver('1.x', '3.x').ranges).to include(SemanticPuppet::VersionRange.parse('1.x'), SemanticPuppet::VersionRange.parse('3.x'))
     end
 
     it 'sem_ver_range() returns PSemVerRangeType' do
@@ -173,7 +173,7 @@ describe 'The type factory' do
       ht = TypeFactory.hash_of_data
       expect(ht.class()).to eq(PHashType)
       expect(ht.key_type.class).to eq(PScalarType)
-      expect(ht.element_type.class).to eq(PDataType)
+      expect(ht.value_type.class).to eq(PDataType)
     end
 
     it 'ruby(1) returns PRuntimeType[ruby, \'Fixnum\']' do
@@ -211,7 +211,7 @@ describe 'The type factory' do
       expect(t.size_type.from).to eq(0)
       expect(t.size_type.to).to eq(0)
       expect(t.key_type).to eq(Puppet::Pops::Types::PUnitType::DEFAULT)
-      expect(t.element_type).to eq(Puppet::Pops::Types::PUnitType::DEFAULT)
+      expect(t.value_type).to eq(Puppet::Pops::Types::PUnitType::DEFAULT)
     end
 
     context 'callable types' do

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

@@ -75,7 +75,7 @@ end
       expect(s.string(f.type_type)).to eq('Type')
     end
 
-    it "should yield 'Object' for PAnyType" do
+    it "should yield 'Any' for PAnyType" do
       expect(s.string(f.any)).to eq('Any')
     end
 
@@ -119,8 +119,12 @@ end
       expect(s.string(f.string)).to eq('String')
     end
 
-    it "should yield 'String' for PStringType with multiple values" do
-      expect(s.string(f.string(nil, 'a', 'b', 'c'))).to eq('String')
+    it "should yield 'String' for PStringType with value" do
+      expect(s.string(f.string('a'))).to eq('String')
+    end
+
+    it "should yield 'String['a']' for PStringType with value if printed with debug_string" do
+      expect(s.debug_string(f.string('a'))).to eq("String['a']")
     end
 
     it "should yield 'String' and from/to for PStringType" do

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

@@ -87,7 +87,7 @@ describe 'the type mismatch describer' do
       check_port({ 34 => 'some service'})
     CODE
     expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
-      /parameter 'ports' expects a PortMap = Hash\[UnprivilegedPort = Integer\[1024, 65537\], String\] value, got Hash\[Integer\[34, 34\], String\[12, 12\]\]/))
+      /parameter 'ports' expects a PortMap = Hash\[UnprivilegedPort = Integer\[1024, 65537\], String\] value, got Hash\[Integer\[34, 34\], String\]/))
   end
 
   it 'will not include the aliased type more than once when reporting a mismatch that involves an alias that is self recursive' do
@@ -98,7 +98,7 @@ describe 'the type mismatch describer' do
       check_tree({ 'x' => {'y' => {32 => 'n'}}})
     CODE
     expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
-      /parameter 'tree' entry 'x' entry 'y' expects a Tree = Hash\[String, Tree\] value, got Hash\[Integer\[32, 32\], String\[1, 1\]\]/))
+      /parameter 'tree' entry 'x' entry 'y' expects a Tree = Hash\[String, Tree\] value, got Hash\[Integer\[32, 32\], String\]/))
   end
 
   it 'will use type normalization' do
@@ -130,6 +130,17 @@ describe 'the type mismatch describer' do
       /parameter 'arg' expects a match for Enum\['a', 'b'\], got Sensitive/))
   end
 
+  it "reports errors on the first failing parameter when that parameter is not the first in order" do
+    code = <<-CODE
+      type Abc = Enum['a', 'b', 'c']
+      type Cde = Enum['c', 'd', 'e']
+      function two_params(Abc $a, Cde $b) {}
+      two_params('a', 'x')
+    CODE
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /parameter 'b' expects a match for Cde = Enum\['c', 'd', 'e'\], got 'x'/))
+  end
+
   it "will not generalize a string that doesn't match an enum in a define call" do
     code = <<-CODE
       define check_enums(Enum[a,b] $arg) {}

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

@@ -386,7 +386,7 @@ describe 'Puppet Type System' do
       type Bar = Fee
       notice(0 =~ Bar)
       CODE
-      expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Type alias 'Foo' cannot be resolved to a real type/)
+      expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Type alias 'Bar' cannot be resolved to a real type/)
     end
 
     it 'will not allow an alias chain that contains nothing but aliases and variants' do
@@ -396,7 +396,7 @@ describe 'Puppet Type System' do
       type Bar = Variant[Fee,Foo]
       notice(0 =~ Bar)
       CODE
-      expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Type alias 'Foo' cannot be resolved to a real type/)
+      expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Type alias 'Bar' cannot be resolved to a real type/)
     end
 
     it 'will not allow an alias to directly reference itself' do
@@ -572,6 +572,29 @@ describe 'Puppet Type System' do
     end
   end
 
+  context 'instantiation via ruby create function' 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 = tf.integer.create('32')
+      expect(int).to eq(32)
+    end
+
+    it 'is supported by Optional[Integer]' do
+      int = tf.optional(tf.integer).create('32')
+      expect(int).to eq(32)
+    end
+
+    it 'is not supported by Any, Scalar, Collection' do
+      [tf.any, tf.scalar, tf.collection ].each do |t|
+        expect { t.create }.to raise_error(ArgumentError, /Creation of new instance of type '#{t.to_s}' is not supported/)
+      end
+    end
+  end
 end
 end
 end

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

@@ -50,42 +50,98 @@ describe "validating 4x" do
   end
 
   context 'with the default settings for --strict' do
-    it 'produces a warning for duplicate keyes in a literal hash' do
+    it 'produces a warning for duplicate keys in a literal hash' do
       acceptor = validate(parse('{ a => 1, a => 2 }'))
       expect(acceptor.warning_count).to eql(1)
       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
     before(:each) { Puppet[:strict] = :warning }
-    it 'produces a warning for duplicate keyes in a literal hash' do
+    it 'produces a warning for duplicate keys in a literal hash' do
       acceptor = validate(parse('{ a => 1, a => 2 }'))
       expect(acceptor.warning_count).to eql(1)
       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 error' do
     before(:each) { Puppet[:strict] = :error }
-    it 'produces an error for duplicate keyes in a literal hash' do
+    it 'produces an error for duplicate keys in a literal hash' do
       acceptor = validate(parse('{ a => 1, a => 2 }'))
       expect(acceptor.warning_count).to eql(0)
       expect(acceptor.error_count).to eql(1)
       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} }'))
+      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 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
   end
 
   context 'with --strict set to off' do
     before(:each) { Puppet[:strict] = :off }
-    it 'does not produce an error or warning for duplicate keyes in a literal hash' do
+    it 'does not produce an error or warning for duplicate keys in a literal hash' do
       acceptor = validate(parse('{ a => 1, a => 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_KEY)
     end
+
+    it 'does not produce 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)
+    end
+
+    it 'does not produce 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(0)
+      expect(acceptor).to_not have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
+    end
   end
 
   context 'for non productive expressions' do

data/spec/unit/provider/nameservice_spec.rb

@@ -301,4 +301,46 @@ describe Puppet::Provider::NameService do
     end
   end
 
+  describe "comments_insync?" do
+    # comments_insync? overrides Puppet::Property#insync? and will act on an
+    # array containing a should value (the expected value of Puppet::Property
+    # @should)
+    context "given strings with compatible encodings" do
+      it "should return false if the is-value and should-value are not equal" do
+        is_value = "foo"
+        should_value = ["bar"]
+        expect(provider.comments_insync?(is_value, should_value)).to be_falsey
+      end
+
+      it "should return true if the is-value and should-value are equal" do
+        is_value = "foo"
+        should_value = ["foo"]
+        expect(provider.comments_insync?(is_value, should_value)).to be_truthy
+      end
+    end
+
+    context "given strings with incompatible encodings" do
+      let(:snowman_iso) { "\u2603".force_encoding(Encoding::ISO_8859_1) }
+      let(:snowman_utf8) { "\u2603".force_encoding(Encoding::UTF_8) }
+      let(:snowman_binary) { "\u2603".force_encoding(Encoding::ASCII_8BIT) }
+      let(:arabic_heh_utf8) { "\u06FF".force_encoding(Encoding::UTF_8) }
+
+      it "should be able to compare unequal strings and return false" do
+        expect(Encoding.compatible?(snowman_iso, arabic_heh_utf8)).to be_falsey
+        expect(provider.comments_insync?(snowman_iso, [arabic_heh_utf8])).to be_falsey
+      end
+
+      it "should be able to compare equal strings and return true" do
+        expect(Encoding.compatible?(snowman_binary, snowman_utf8)).to be_falsey
+        expect(provider.comments_insync?(snowman_binary, [snowman_utf8])).to be_truthy
+      end
+
+      it "should not manipulate the actual encoding of either string" do
+        expect(Encoding.compatible?(snowman_binary, snowman_utf8)).to be_falsey
+        provider.comments_insync?(snowman_binary, [snowman_utf8])
+        expect(snowman_binary.encoding).to eq(Encoding::ASCII_8BIT)
+        expect(snowman_utf8.encoding).to eq(Encoding::UTF_8)
+      end
+    end
+  end
 end

data/spec/unit/provider/package/aptrpm_spec.rb

@@ -17,7 +17,7 @@ describe Puppet::Type.type(:package).provider(:aptrpm) do
     end
 
     def rpm_args
-      ['-q', 'faff', '--nosignature', '--nodigest', '--qf', "%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\\n"]
+      ['-q', 'faff', '--nosignature', '--nodigest', '--qf', "'%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\\n'"]
     end
 
     def rpm(args = rpm_args)

data/spec/unit/provider/package/pkg_spec.rb

@@ -25,6 +25,28 @@ describe Puppet::Type.type(:package).provider(:pkg) do
 
   it_should_respond_to :install, :uninstall, :update, :query, :latest
 
+  context 'default' do
+    [ 10 ].each do |ver|
+      it "should not be the default provider on Solaris #{ver}" do
+        Facter.stubs(:value).with(:osfamily).returns(:Solaris)
+        Facter.stubs(:value).with(:kernelrelease).returns("5.#{ver}")
+        Facter.stubs(:value).with(:operatingsystem).returns(:Solaris)
+        Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
+        expect(described_class).to_not be_default
+      end
+    end
+
+    [ 11, 12 ].each do |ver|
+      it "should be the default provider on Solaris #{ver}" do
+        Facter.stubs(:value).with(:osfamily).returns(:Solaris)
+        Facter.stubs(:value).with(:kernelrelease).returns("5.#{ver}")
+        Facter.stubs(:value).with(:operatingsystem).returns(:Solaris)
+        Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
+        expect(described_class).to be_default
+      end
+    end
+  end
+
   it "should be versionable" do
     expect(described_class).to be_versionable
   end